llonebot-dist 7.12.2 → 7.12.3

package/llbot.js

@@ -1,15 +1,14 @@
 import { createRequire } from "node:module";
 import * as path$4 from "node:path";
-import path, { dirname } from "node:path";
+import path, { dirname, join } from "node:path";
 import fs, { access, copyFile, mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
-import fs$1, { createReadStream, existsSync, statSync } from "fs";
-import { Readable } from "stream";
+import fs$1, { existsSync } from "fs";
 import * as fs$6 from "node:fs";
-import fs$2, { appendFile, appendFileSync, createReadStream as createReadStream$1, existsSync as existsSync$1, mkdirSync, promises, stat as stat$1, watch } from "node:fs";
+import fs$2, { appendFile, appendFileSync, createReadStream, existsSync as existsSync$1, mkdirSync, promises, stat as stat$1, statSync, watch } from "node:fs";
 import os from "node:os";
 import { Binary, Time, camelize, clone, deduplicate, deepEqual, defineProperty, difference, filterKeys, hyphenate, is, isNonNullable, isNullable, isPlainObject, makeArray, mapValues, noop, omit, pick, remove, valueMap } from "cosmokit";
 import { Exporter, Factory } from "reggol";
-import path$1, { join } from "path";
+import path$1 from "path";
 import { networkInterfaces } from "os";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { WebSocket as WebSocket$1, WebSocketServer } from "ws";
@@ -17,17 +16,15 @@ import { constants } from "node:buffer";
 import crypto$1, { createHash, randomBytes, randomInt, randomUUID } from "node:crypto";
 import * as fileType from "file-type";
 import { decode, encode, getDuration, getWavFileInfo, isSilk, isWav } from "silk-wasm";
-import { createServer } from "http";
-import { Http2ServerRequest, constants as constants$1 } from "http2";
-import crypto$2 from "crypto";
+import http, { STATUS_CODES, createServer, request } from "node:http";
+import { Http2ServerRequest, constants as constants$1 } from "node:http2";
+import { Readable, Transform } from "node:stream";
 import { deflateSync, gunzipSync, gzipSync, inflateSync } from "node:zlib";
 import fsPromise, { stat as stat$2, unlink as unlink$1 } from "fs/promises";
-import http, { STATUS_CODES, request } from "node:http";
 import { inspect, isDeepStrictEqual } from "node:util";
-import { Transform } from "node:stream";
 import net, { connect } from "node:net";
 import https from "node:https";
-import { versions } from "process";
+import { versions } from "node:process";
 //#region \0rolldown/runtime.js
 var __create$2 = Object.create;
 var __defProp$9 = Object.defineProperty;
@@ -36,7 +33,7 @@ var __getOwnPropNames$2 = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 var __exportAll = (all, no_symbols) => {
 	let target = {};
 	for (var name in all) __defProp$9(target, name, {
@@ -1623,6 +1620,9 @@ var require_dijkstra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			var predecessors = dijkstra.single_source_shortest_paths(graph, s, d);
 			return dijkstra.extract_shortest_path_from_predecessor_list(predecessors, d);
 		},
+		/**
+		* A very naive priority queue implementation.
+		*/
 		PriorityQueue: {
 			make: function(opts) {
 				var T = dijkstra.PriorityQueue, t = {}, key;
@@ -1635,6 +1635,10 @@ var require_dijkstra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			default_sorter: function(a, b) {
 				return a.cost - b.cost;
 			},
+			/**
+			* Add a new item to the queue and ensure the highest priority element
+			* is at the front of the queue.
+			*/
 			push: function(value, cost) {
 				var item = {
 					value,
@@ -1643,6 +1647,9 @@ var require_dijkstra = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				this.queue.push(item);
 				this.queue.sort(this.sorter);
 			},
+			/**
+			* Return the highest priority element in the queue.
+			*/
 			pop: function() {
 				return this.queue.shift();
 			},
@@ -3509,7 +3516,8 @@ var require_packer_async = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var Packer = require_packer();
 	var PackerAsync = module.exports = function(opt) {
 		Stream$2.call(this);
-		this._packer = new Packer(opt || {});
+		let options = opt || {};
+		this._packer = new Packer(options);
 		this._deflate = this._packer.createDeflate();
 		this.readable = true;
 	};
@@ -6506,20 +6514,20 @@ var MsgType = /* @__PURE__ */ function(MsgType) {
 //#region src/ntqqapi/types/notify.ts
 var GroupNotifyType = /* @__PURE__ */ function(GroupNotifyType) {
 	GroupNotifyType[GroupNotifyType["InvitedByMember"] = 1] = "InvitedByMember";
-	GroupNotifyType[GroupNotifyType["RefuseInvited"] = 2] = "RefuseInvited";
-	GroupNotifyType[GroupNotifyType["RefusedByAdminiStrator"] = 3] = "RefusedByAdminiStrator";
-	GroupNotifyType[GroupNotifyType["AgreedTojoinDirect"] = 4] = "AgreedTojoinDirect";
-	GroupNotifyType[GroupNotifyType["InvitedNeedAdminiStratorPass"] = 5] = "InvitedNeedAdminiStratorPass";
-	GroupNotifyType[GroupNotifyType["AgreedToJoinByAdminiStrator"] = 6] = "AgreedToJoinByAdminiStrator";
-	GroupNotifyType[GroupNotifyType["RequestJoinNeedAdminiStratorPass"] = 7] = "RequestJoinNeedAdminiStratorPass";
-	GroupNotifyType[GroupNotifyType["SetAdmin"] = 8] = "SetAdmin";
-	GroupNotifyType[GroupNotifyType["KickMemberNotifyAdmin"] = 9] = "KickMemberNotifyAdmin";
-	GroupNotifyType[GroupNotifyType["KickMemberNotifyKicked"] = 10] = "KickMemberNotifyKicked";
-	GroupNotifyType[GroupNotifyType["MemberLeaveNotifyAdmin"] = 11] = "MemberLeaveNotifyAdmin";
-	GroupNotifyType[GroupNotifyType["CancelAdminNotifyCanceled"] = 12] = "CancelAdminNotifyCanceled";
-	GroupNotifyType[GroupNotifyType["CancelAdminNotifyAdmin"] = 13] = "CancelAdminNotifyAdmin";
-	GroupNotifyType[GroupNotifyType["TransferGroupNotifyOldowner"] = 14] = "TransferGroupNotifyOldowner";
-	GroupNotifyType[GroupNotifyType["TransferGroupNotifyAdmin"] = 15] = "TransferGroupNotifyAdmin";
+	GroupNotifyType[GroupNotifyType["RefuseInvited"] = 1 + GroupNotifyType["InvitedByMember"]] = "RefuseInvited";
+	GroupNotifyType[GroupNotifyType["RefusedByAdminiStrator"] = 1 + GroupNotifyType["RefuseInvited"]] = "RefusedByAdminiStrator";
+	GroupNotifyType[GroupNotifyType["AgreedTojoinDirect"] = 1 + GroupNotifyType["RefusedByAdminiStrator"]] = "AgreedTojoinDirect";
+	GroupNotifyType[GroupNotifyType["InvitedNeedAdminiStratorPass"] = 1 + GroupNotifyType["AgreedTojoinDirect"]] = "InvitedNeedAdminiStratorPass";
+	GroupNotifyType[GroupNotifyType["AgreedToJoinByAdminiStrator"] = 1 + GroupNotifyType["InvitedNeedAdminiStratorPass"]] = "AgreedToJoinByAdminiStrator";
+	GroupNotifyType[GroupNotifyType["RequestJoinNeedAdminiStratorPass"] = 1 + GroupNotifyType["AgreedToJoinByAdminiStrator"]] = "RequestJoinNeedAdminiStratorPass";
+	GroupNotifyType[GroupNotifyType["SetAdmin"] = 1 + GroupNotifyType["RequestJoinNeedAdminiStratorPass"]] = "SetAdmin";
+	GroupNotifyType[GroupNotifyType["KickMemberNotifyAdmin"] = 1 + GroupNotifyType["SetAdmin"]] = "KickMemberNotifyAdmin";
+	GroupNotifyType[GroupNotifyType["KickMemberNotifyKicked"] = 1 + GroupNotifyType["KickMemberNotifyAdmin"]] = "KickMemberNotifyKicked";
+	GroupNotifyType[GroupNotifyType["MemberLeaveNotifyAdmin"] = 1 + GroupNotifyType["KickMemberNotifyKicked"]] = "MemberLeaveNotifyAdmin";
+	GroupNotifyType[GroupNotifyType["CancelAdminNotifyCanceled"] = 1 + GroupNotifyType["MemberLeaveNotifyAdmin"]] = "CancelAdminNotifyCanceled";
+	GroupNotifyType[GroupNotifyType["CancelAdminNotifyAdmin"] = 1 + GroupNotifyType["CancelAdminNotifyCanceled"]] = "CancelAdminNotifyAdmin";
+	GroupNotifyType[GroupNotifyType["TransferGroupNotifyOldowner"] = 1 + GroupNotifyType["CancelAdminNotifyAdmin"]] = "TransferGroupNotifyOldowner";
+	GroupNotifyType[GroupNotifyType["TransferGroupNotifyAdmin"] = 1 + GroupNotifyType["TransferGroupNotifyOldowner"]] = "TransferGroupNotifyAdmin";
 	return GroupNotifyType;
 }({});
 var GroupNotifyStatus = /* @__PURE__ */ function(GroupNotifyStatus) {
@@ -6832,11 +6840,30 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var utils = module.exports = {
 		isWindows,
 		streamRegexp,
+		/**
+		* Copy an object keys into another one
+		*
+		* @param {Object} source source object
+		* @param {Object} dest destination object
+		* @private
+		*/
 		copy: function(source, dest) {
 			Object.keys(source).forEach(function(key) {
 				dest[key] = source[key];
 			});
 		},
+		/**
+		* Create an argument list
+		*
+		* Returns a function that adds new arguments to the list.
+		* It also has the following methods:
+		* - clear() empties the argument list
+		* - get() returns the argument list
+		* - find(arg, count) finds 'arg' in the list and return the following 'count' items, or undefined if not found
+		* - remove(arg, count) remove 'arg' in the list as well as the following 'count' items
+		*
+		* @private
+		*/
 		args: function() {
 			var list = [];
 			var argfunc = function() {
@@ -6864,6 +6891,20 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			};
 			return argfunc;
 		},
+		/**
+		* Generate filter strings
+		*
+		* @param {String[]|Object[]} filters filter specifications. When using objects,
+		*   each must have the following properties:
+		* @param {String} filters.filter filter name
+		* @param {String|Array} [filters.inputs] (array of) input stream specifier(s) for the filter,
+		*   defaults to ffmpeg automatically choosing the first unused matching streams
+		* @param {String|Array} [filters.outputs] (array of) output stream specifier(s) for the filter,
+		*   defaults to ffmpeg automatically assigning the output to the output file
+		* @param {Object|String|Array} [filters.options] filter options, can be omitted to not set any options
+		* @return String[]
+		* @private
+		*/
 		makeFilterStrings: function(filters) {
 			return filters.map(function(filterSpec) {
 				if (typeof filterSpec === "string") return filterSpec;
@@ -6892,6 +6933,15 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				return filterString;
 			});
 		},
+		/**
+		* Search for an executable
+		*
+		* Uses 'which' or 'where' depending on platform
+		*
+		* @param {String} name executable name
+		* @param {Function} callback callback with signature (err, path)
+		* @private
+		*/
 		which: function(name, callback) {
 			if (name in whichCache) return callback(null, whichCache[name]);
 			which(name, function(err, result) {
@@ -6899,6 +6949,13 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				callback(null, whichCache[name] = result);
 			});
 		},
+		/**
+		* Convert a [[hh:]mm:]ss[.xxx] timemark into seconds
+		*
+		* @param {String} timemark timemark string
+		* @return Number
+		* @private
+		*/
 		timemarkToSeconds: function(timemark) {
 			if (typeof timemark === "number") return timemark;
 			if (timemark.indexOf(":") === -1 && timemark.indexOf(".") >= 0) return Number(timemark);
@@ -6908,6 +6965,16 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			if (parts.length) secs += Number(parts.pop()) * 3600;
 			return secs;
 		},
+		/**
+		* Extract codec data from ffmpeg stderr and emit 'codecData' event if appropriate
+		* Call it with an initially empty codec object once with each line of stderr output until it returns true
+		*
+		* @param {FfmpegCommand} command event emitter
+		* @param {String} stderrLine ffmpeg stderr output line
+		* @param {Object} codecObject object used to accumulate codec data between calls
+		* @return {Boolean} true if codec data is complete (and event was emitted), false otherwise
+		* @private
+		*/
 		extractCodecData: function(command, stderrLine, codecsObject) {
 			var inputPattern = /Input #[0-9]+, ([^ ]+),/;
 			var durPattern = /Duration\: ([^,]+)/;
@@ -6947,6 +7014,13 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 			return false;
 		},
+		/**
+		* Extract progress data from ffmpeg stderr and emit 'progress' event if appropriate
+		*
+		* @param {FfmpegCommand} command event emitter
+		* @param {String} stderrLine ffmpeg stderr data
+		* @private
+		*/
 		extractProgress: function(command, stderrLine) {
 			var progress = parseProgressLine(stderrLine);
 			if (progress) {
@@ -6964,6 +7038,13 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				command.emit("progress", ret);
 			}
 		},
+		/**
+		* Extract error message(s) from ffmpeg stderr
+		*
+		* @param {String} stderr ffmpeg stderr data
+		* @return {String}
+		* @private
+		*/
 		extractError: function(stderr) {
 			return stderr.split(nlRegexp).reduce(function(messages, message) {
 				if (message.charAt(0) === " " || message.charAt(0) === "[") return [];
@@ -6973,6 +7054,15 @@ var require_utils = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				}
 			}, []).join("\n");
 		},
+		/**
+		* Creates a line ring buffer object with the following methods:
+		* - append(str) : appends a string or buffer
+		* - get() : returns the whole string
+		* - close() : prevents further append() calls and does a last call to callbacks
+		* - callback(cb) : calls cb for each line (incl. those already in the ring)
+		*
+		* @param {Number} maxLines maximum number of lines to store (<= 0 for unlimited)
+		*/
 		linesRing: function(maxLines) {
 			var cbs = [];
 			var lines = [];
@@ -11292,7 +11382,7 @@ var OB11HeartbeatEvent = class extends OB11BaseMetaEvent {
 };
 //#endregion
 //#region src/version.ts
-var version$2 = "7.12.2";
+var version$2 = "7.12.3";
 //#endregion
 //#region node_modules/sift/es5m/index.js
 /******************************************************************************
@@ -11726,7 +11816,8 @@ var $In = function(_super) {
 	}
 	$In.prototype.init = function() {
 		var _this = this;
-		this._testers = (Array.isArray(this.params) ? this.params : [this.params]).map(function(value) {
+		var params = Array.isArray(this.params) ? this.params : [this.params];
+		this._testers = params.map(function(value) {
 			if (containsOperation(value, _this.options)) throw new Error("cannot nest $ under ".concat(_this.name.toLowerCase()));
 			return createTester(value, _this.options.compare);
 		});
@@ -20295,6 +20386,27 @@ var streamSSE = (c, cb, onError) => {
 	return c.newResponse(stream.responseReadable);
 };
 //#endregion
+//#region node_modules/hono/dist/helper/websocket/index.js
+var defineWebSocketHelper = (handler) => {
+	return ((...args) => {
+		if (typeof args[0] === "function") {
+			const [createEvents, options] = args;
+			return async function upgradeWebSocket(c, next) {
+				const result = await handler(c, await createEvents(c), options);
+				if (result) return result;
+				await next();
+			};
+		} else {
+			const [c, events, options] = args;
+			return (async () => {
+				const upgraded = await handler(c, events, options);
+				if (!upgraded) throw new Error("Failed to upgrade WebSocket");
+				return upgraded;
+			})();
+		}
+	});
+};
+//#endregion
 //#region node_modules/@hono/node-server/dist/index.mjs
 var RequestError = class extends Error {
 	constructor(message, options) {
@@ -20302,6 +20414,22 @@ var RequestError = class extends Error {
 		this.name = "RequestError";
 	}
 };
+var reValidRequestUrl = /^\/[!#$&-;=?-\[\]_a-z~]*$/;
+var reDotSegment = /\/\.\.?(?:[/?#]|$)/;
+var reValidHost = /^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/;
+var buildUrl = (scheme, host, incomingUrl) => {
+	const url = `${scheme}://${host}${incomingUrl}`;
+	if (!reValidHost.test(host)) {
+		const urlObj = new URL(url);
+		if (urlObj.hostname.length !== host.length && urlObj.hostname !== (host.includes(":") ? host.replace(/:\d+$/, "") : host).toLowerCase()) throw new RequestError("Invalid host header");
+		return urlObj.href;
+	} else if (incomingUrl.length === 0) return url + "/";
+	else {
+		if (incomingUrl.charCodeAt(0) !== 47) throw new RequestError("Invalid URL");
+		if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl)) return new URL(url).href;
+		return url;
+	}
+};
 var toRequestError = (e) => {
 	if (e instanceof RequestError) return e;
 	return new RequestError(e.message, { cause: e });
@@ -20309,17 +20437,21 @@ var toRequestError = (e) => {
 var GlobalRequest = global.Request;
 var Request$1 = class extends GlobalRequest {
 	constructor(input, options) {
-		if (typeof input === "object" && getRequestCache in input) input = input[getRequestCache]();
-		if (typeof options?.body?.getReader !== "undefined") options.duplex ??= "half";
+		if (typeof input === "object" && getRequestCache in input) {
+			const hasReplacementBody = options !== void 0 && "body" in options && options.body != null;
+			if (input[bodyConsumedDirectlyKey] && !hasReplacementBody) throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
+			input = input[getRequestCache]();
+		}
+		if (typeof (options?.body)?.getReader !== "undefined") options.duplex ??= "half";
 		super(input, options);
 	}
 };
 var newHeadersFromIncoming = (incoming) => {
 	const headerRecord = [];
 	const rawHeaders = incoming.rawHeaders;
-	for (let i = 0; i < rawHeaders.length; i += 2) {
-		const { [i]: key, [i + 1]: value } = rawHeaders;
-		if (key.charCodeAt(0) !== 58) headerRecord.push([key, value]);
+	for (let i = 0, len = rawHeaders.length; i < len; i += 2) {
+		const key = rawHeaders[i];
+		if (key.charCodeAt(0) !== 58) headerRecord.push([key, rawHeaders[i + 1]]);
 	}
 	return new Headers(headerRecord);
 };
@@ -20361,11 +20493,158 @@ var getRequestCache = Symbol("getRequestCache");
 var requestCache = Symbol("requestCache");
 var incomingKey = Symbol("incomingKey");
 var urlKey = Symbol("urlKey");
+var methodKey = Symbol("methodKey");
 var headersKey = Symbol("headersKey");
 var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var abortRequest = Symbol("abortRequest");
+var bodyBufferKey = Symbol("bodyBuffer");
+var bodyReadPromiseKey = Symbol("bodyReadPromise");
+var bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
+var bodyLockReaderKey = Symbol("bodyLockReader");
+var abortReasonKey = Symbol("abortReason");
+var newBodyUnusableError = () => {
+	return /* @__PURE__ */ new TypeError("Body is unusable");
+};
+var rejectBodyUnusable = () => {
+	return Promise.reject(newBodyUnusableError());
+};
+var textDecoder = new TextDecoder();
+var consumeBodyDirectOnce = (request) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	request[bodyConsumedDirectlyKey] = true;
+};
+var toArrayBuffer = (buf) => {
+	return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+};
+var contentType = (request) => {
+	return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
+};
+var methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var normalizeIncomingMethod = (method) => {
+	if (typeof method !== "string" || method.length === 0) return "GET";
+	switch (method) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "POST":
+		case "PUT": return method;
+	}
+	const upper = method.toUpperCase();
+	switch (upper) {
+		case "DELETE":
+		case "GET":
+		case "HEAD":
+		case "OPTIONS":
+		case "POST":
+		case "PUT": return upper;
+		default: return method;
+	}
+};
+var validateDirectReadMethod = (method) => {
+	if (!methodTokenRegExp.test(method)) return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
+	const normalized = method.toUpperCase();
+	if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE") return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
+};
+var readBodyWithFastPath = (request, method, fromBuffer) => {
+	if (request[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	const methodName = request.method;
+	if (methodName === "GET" || methodName === "HEAD") return request[getRequestCache]()[method]();
+	const methodValidationError = validateDirectReadMethod(methodName);
+	if (methodValidationError) return Promise.reject(methodValidationError);
+	if (request[requestCache]) {
+		if (methodName !== "TRACE") return request[requestCache][method]();
+	}
+	const alreadyUsedError = consumeBodyDirectOnce(request);
+	if (alreadyUsedError) return alreadyUsedError;
+	const raw = readRawBodyIfAvailable(request);
+	if (raw) {
+		const result = Promise.resolve(fromBuffer(raw, request));
+		request[bodyBufferKey] = void 0;
+		return result;
+	}
+	return readBodyDirect(request).then((buf) => {
+		const result = fromBuffer(buf, request);
+		request[bodyBufferKey] = void 0;
+		return result;
+	});
+};
+var readRawBodyIfAvailable = (request) => {
+	const incoming = request[incomingKey];
+	if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) return incoming.rawBody;
+};
+var readBodyDirect = (request) => {
+	if (request[bodyBufferKey]) return Promise.resolve(request[bodyBufferKey]);
+	if (request[bodyReadPromiseKey]) return request[bodyReadPromiseKey];
+	const incoming = request[incomingKey];
+	if (Readable.isDisturbed(incoming)) return rejectBodyUnusable();
+	const promise = new Promise((resolve, reject) => {
+		const chunks = [];
+		let settled = false;
+		const finish = (callback) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			callback();
+		};
+		const onData = (chunk) => {
+			chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		};
+		const onEnd = () => {
+			finish(() => {
+				const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+				request[bodyBufferKey] = buffer;
+				resolve(buffer);
+			});
+		};
+		const onError = (error) => {
+			finish(() => {
+				reject(error);
+			});
+		};
+		const onClose = () => {
+			if (incoming.readableEnded) {
+				onEnd();
+				return;
+			}
+			finish(() => {
+				if (incoming.errored) {
+					reject(incoming.errored);
+					return;
+				}
+				const reason = request[abortReasonKey];
+				if (reason !== void 0) {
+					reject(reason instanceof Error ? reason : new Error(String(reason)));
+					return;
+				}
+				reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+			});
+		};
+		const cleanup = () => {
+			incoming.off("data", onData);
+			incoming.off("end", onEnd);
+			incoming.off("error", onError);
+			incoming.off("close", onClose);
+			request[bodyReadPromiseKey] = void 0;
+		};
+		incoming.on("data", onData);
+		incoming.on("end", onEnd);
+		incoming.on("error", onError);
+		incoming.on("close", onClose);
+		queueMicrotask(() => {
+			if (settled) return;
+			if (incoming.readableEnded) onEnd();
+			else if (incoming.errored) onError(incoming.errored);
+			else if (incoming.destroyed) onClose();
+		});
+	});
+	request[bodyReadPromiseKey] = promise;
+	return promise;
+};
 var requestPrototype = {
 	get method() {
-		return this[incomingKey].method || "GET";
+		return this[methodKey];
 	},
 	get url() {
 		return this[urlKey];
@@ -20373,18 +20652,57 @@ var requestPrototype = {
 	get headers() {
 		return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
 	},
-	[Symbol("getAbortController")]() {
-		this[getRequestCache]();
+	[abortRequest](reason) {
+		if (this[abortReasonKey] === void 0) this[abortReasonKey] = reason;
+		const abortController = this[abortControllerKey];
+		if (abortController && !abortController.signal.aborted) abortController.abort(reason);
+	},
+	[getAbortController]() {
+		this[abortControllerKey] ||= new AbortController();
+		if (this[abortReasonKey] !== void 0 && !this[abortControllerKey].signal.aborted) this[abortControllerKey].abort(this[abortReasonKey]);
 		return this[abortControllerKey];
 	},
 	[getRequestCache]() {
-		this[abortControllerKey] ||= new AbortController();
-		return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
+		const abortController = this[getAbortController]();
+		if (this[requestCache]) return this[requestCache];
+		const method = this.method;
+		if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
+			this[bodyBufferKey] = void 0;
+			const init = {
+				method: method === "TRACE" ? "GET" : method,
+				headers: this.headers,
+				signal: abortController.signal
+			};
+			if (method !== "TRACE") {
+				init.body = new ReadableStream({ start(c) {
+					c.close();
+				} });
+				init.duplex = "half";
+			}
+			const req = new Request$1(this[urlKey], init);
+			if (method === "TRACE") Object.defineProperty(req, "method", { get() {
+				return "TRACE";
+			} });
+			return this[requestCache] = req;
+		}
+		return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
+	},
+	get body() {
+		if (!this[bodyConsumedDirectlyKey]) return this[getRequestCache]().body;
+		const request = this[getRequestCache]();
+		if (!this[bodyLockReaderKey] && request.body) this[bodyLockReaderKey] = request.body.getReader();
+		return request.body;
+	},
+	get bodyUsed() {
+		if (this[bodyConsumedDirectlyKey]) return true;
+		if (this[requestCache]) return this[requestCache].bodyUsed;
+		return false;
 	}
 };
+Object.defineProperty(requestPrototype, "signal", { get() {
+	return this[getAbortController]().signal;
+} });
 [
-	"body",
-	"bodyUsed",
 	"cache",
 	"credentials",
 	"destination",
@@ -20393,25 +20711,37 @@ var requestPrototype = {
 	"redirect",
 	"referrer",
 	"referrerPolicy",
-	"signal",
 	"keepalive"
 ].forEach((k) => {
 	Object.defineProperty(requestPrototype, k, { get() {
 		return this[getRequestCache]()[k];
 	} });
 });
-[
-	"arrayBuffer",
-	"blob",
-	"clone",
-	"formData",
-	"json",
-	"text"
-].forEach((k) => {
+["clone", "formData"].forEach((k) => {
 	Object.defineProperty(requestPrototype, k, { value: function() {
+		if (this[bodyConsumedDirectlyKey]) {
+			if (k === "clone") throw newBodyUnusableError();
+			return rejectBodyUnusable();
+		}
 		return this[getRequestCache]()[k]();
 	} });
 });
+Object.defineProperty(requestPrototype, "text", { value: function() {
+	return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
+} });
+Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
+	return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
+} });
+Object.defineProperty(requestPrototype, "blob", { value: function() {
+	return readBodyWithFastPath(this, "blob", (buf, request) => {
+		const type = contentType(request);
+		return new Response(buf, type ? { headers: { "content-type": type } } : void 0).blob();
+	});
+} });
+Object.defineProperty(requestPrototype, "json", { value: function() {
+	if (this[bodyConsumedDirectlyKey]) return rejectBodyUnusable();
+	return this.text().then(JSON.parse);
+} });
 Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
 	return `Request (lightweight) ${inspectFn({
 		method: this.method,
@@ -20427,6 +20757,7 @@ Object.setPrototypeOf(requestPrototype, Request$1.prototype);
 var newRequest = (incoming, defaultHostname) => {
 	const req = Object.create(requestPrototype);
 	req[incomingKey] = incoming;
+	req[methodKey] = normalizeIncomingMethod(incoming.method);
 	const incomingUrl = incoming.url || "";
 	if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
 		if (incoming instanceof Http2ServerRequest) throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
@@ -20444,16 +20775,20 @@ var newRequest = (incoming, defaultHostname) => {
 		scheme = incoming.scheme;
 		if (!(scheme === "http" || scheme === "https")) throw new RequestError("Unsupported scheme");
 	} else scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
-	const url = new URL(`${scheme}://${host}${incomingUrl}`);
-	if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) throw new RequestError("Invalid host header");
-	req[urlKey] = url.href;
+	try {
+		req[urlKey] = buildUrl(scheme, host, incomingUrl);
+	} catch (e) {
+		if (e instanceof RequestError) throw e;
+		else throw new RequestError("Invalid URL", { cause: e });
+	}
 	return req;
 };
+var defaultContentType = "text/plain; charset=UTF-8";
 var responseCache = Symbol("responseCache");
 var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
-var Response2 = class _Response {
+var Response$1 = class Response$1 {
 	#body;
 	#init;
 	[getResponseCache]() {
@@ -20463,7 +20798,7 @@ var Response2 = class _Response {
 	constructor(body, init) {
 		let headers;
 		this.#body = body;
-		if (init instanceof _Response) {
+		if (init instanceof Response$1) {
 			const cachedGlobalResponse = init[responseCache];
 			if (cachedGlobalResponse) {
 				this.#init = cachedGlobalResponse;
@@ -20474,16 +20809,16 @@ var Response2 = class _Response {
 				headers = new Headers(init.#init.headers);
 			}
 		} else this.#init = init;
-		if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
+		if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) this[cacheKey] = [
 			init?.status || 200,
-			body,
+			body ?? null,
 			headers || init?.headers
 		];
 	}
 	get headers() {
 		const cache = this[cacheKey];
 		if (cache) {
-			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+			if (!(cache[2] instanceof Headers)) cache[2] = new Headers(cache[2] || (cache[1] === null ? void 0 : { "content-type": defaultContentType }));
 			return cache[2];
 		}
 		return this[getResponseCache]().headers;
@@ -20505,7 +20840,7 @@ var Response2 = class _Response {
 	"type",
 	"url"
 ].forEach((k) => {
-	Object.defineProperty(Response2.prototype, k, { get() {
+	Object.defineProperty(Response$1.prototype, k, { get() {
 		return this[getResponseCache]()[k];
 	} });
 });
@@ -20517,11 +20852,11 @@ var Response2 = class _Response {
 	"json",
 	"text"
 ].forEach((k) => {
-	Object.defineProperty(Response2.prototype, k, { value: function() {
+	Object.defineProperty(Response$1.prototype, k, { value: function() {
 		return this[getResponseCache]()[k]();
 	} });
 });
-Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+Object.defineProperty(Response$1.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
 	return `Response (lightweight) ${inspectFn({
 		status: this.status,
 		headers: this.headers,
@@ -20532,8 +20867,51 @@ Object.defineProperty(Response2.prototype, Symbol.for("nodejs.util.inspect.custo
 		depth: depth == null ? null : depth - 1
 	})}`;
 } });
-Object.setPrototypeOf(Response2, GlobalResponse);
-Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+Object.setPrototypeOf(Response$1, GlobalResponse);
+Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
+var validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/;
+var parseRedirectUrl = (url) => {
+	if (url instanceof URL) return url.href;
+	if (validRedirectUrl.test(url)) return url;
+	return new URL(url).href;
+};
+var validRedirectStatuses = new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+Object.defineProperty(Response$1, "redirect", {
+	value: function redirect(url, status = 302) {
+		if (!validRedirectStatuses.has(status)) throw new RangeError("Invalid status code");
+		return new Response$1(null, {
+			status,
+			headers: { location: parseRedirectUrl(url) }
+		});
+	},
+	writable: true,
+	configurable: true
+});
+Object.defineProperty(Response$1, "json", {
+	value: function json(data, init) {
+		const body = JSON.stringify(data);
+		if (body === void 0) throw new TypeError("The data is not JSON serializable");
+		const initHeaders = init?.headers;
+		let headers;
+		if (initHeaders) {
+			headers = new Headers(initHeaders);
+			if (!headers.has("content-type")) headers.set("content-type", "application/json");
+		} else headers = { "content-type": "application/json" };
+		return new Response$1(body, {
+			status: init?.status ?? 200,
+			statusText: init?.statusText,
+			headers
+		});
+	},
+	writable: true,
+	configurable: true
+});
 async function readWithoutBlocking(readPromise) {
 	return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
 }
@@ -20569,18 +20947,18 @@ function writeFromReadableStream(stream, writable) {
 	else if (writable.destroyed) return;
 	return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
 }
-var buildOutgoingHttpHeaders = (headers) => {
+var buildOutgoingHttpHeaders = (headers, defaultContentType) => {
 	const res = {};
 	if (!(headers instanceof Headers)) headers = new Headers(headers ?? void 0);
-	const cookies = [];
-	for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
-	else res[k] = v;
-	if (cookies.length > 0) res["set-cookie"] = cookies;
-	res["content-type"] ??= "text/plain; charset=UTF-8";
+	if (headers.has("set-cookie")) {
+		const cookies = [];
+		for (const [k, v] of headers) if (k === "set-cookie") cookies.push(v);
+		else res[k] = v;
+		if (cookies.length > 0) res["set-cookie"] = cookies;
+	} else for (const [k, v] of headers) res[k] = v;
+	if (defaultContentType) res["content-type"] ??= defaultContentType;
 	return res;
 };
-var X_ALREADY_SENT = "x-hono-already-sent";
-if (typeof global.crypto === "undefined") global.crypto = crypto$2;
 var outgoingEnded = Symbol("outgoingEnded");
 var incomingDraining = Symbol("incomingDraining");
 var DRAIN_TIMEOUT_MS = 500;
@@ -20618,6 +20996,20 @@ var drainIncoming = (incoming) => {
 	incoming.on("error", cleanup);
 	incoming.resume();
 };
+var makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
+	if (incoming.errored) req[abortRequest](incoming.errored.toString());
+	else if (!outgoing.writableFinished) req[abortRequest]("Client connection prematurely closed.");
+	if (needsBodyCleanup && !incoming.readableEnded) setTimeout(() => {
+		if (!incoming.readableEnded) setTimeout(() => {
+			drainIncoming(incoming);
+		});
+	});
+};
+var isImmediateCacheableResponse = (res) => {
+	if (!(cacheKey in res)) return false;
+	const body = res[cacheKey][1];
+	return body === null || typeof body === "string" || body instanceof Uint8Array;
+};
 var handleRequestError = () => new Response(null, { status: 400 });
 var handleFetchError = (e) => new Response(null, { status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500 });
 var handleResponseError = (e, outgoing) => {
@@ -20635,15 +21027,44 @@ var flushHeaders = (outgoing) => {
 };
 var responseViaCache = async (res, outgoing) => {
 	let [status, body, header] = res[cacheKey];
+	if (!header) {
+		if (body === null) {
+			outgoing.writeHead(status);
+			outgoing.end();
+		} else if (typeof body === "string") {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": Buffer.byteLength(body)
+			});
+			outgoing.end(body);
+		} else if (body instanceof Uint8Array) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": body.byteLength
+			});
+			outgoing.end(body);
+		} else if (body instanceof Blob) {
+			outgoing.writeHead(status, {
+				"Content-Type": defaultContentType,
+				"Content-Length": body.size
+			});
+			outgoing.end(new Uint8Array(await body.arrayBuffer()));
+		} else {
+			outgoing.writeHead(status, { "Content-Type": defaultContentType });
+			flushHeaders(outgoing);
+			await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+		}
+		outgoing[outgoingEnded]?.();
+		return;
+	}
 	let hasContentLength = false;
-	if (!header) header = { "content-type": "text/plain; charset=UTF-8" };
-	else if (header instanceof Headers) {
+	if (header instanceof Headers) {
 		hasContentLength = header.has("content-length");
-		header = buildOutgoingHttpHeaders(header);
+		header = buildOutgoingHttpHeaders(header, body === null ? void 0 : defaultContentType);
 	} else if (Array.isArray(header)) {
 		const headerObj = new Headers(header);
 		hasContentLength = headerObj.has("content-length");
-		header = buildOutgoingHttpHeaders(headerObj);
+		header = buildOutgoingHttpHeaders(headerObj, body === null ? void 0 : defaultContentType);
 	} else for (const key in header) if (key.length === 14 && key.toLowerCase() === "content-length") {
 		hasContentLength = true;
 		break;
@@ -20654,7 +21075,8 @@ var responseViaCache = async (res, outgoing) => {
 		else if (body instanceof Blob) header["Content-Length"] = body.size;
 	}
 	outgoing.writeHead(status, header);
-	if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
+	if (body == null) outgoing.end();
+	else if (typeof body === "string" || body instanceof Uint8Array) outgoing.end(body);
 	else if (body instanceof Blob) outgoing.end(new Uint8Array(await body.arrayBuffer()));
 	else {
 		flushHeaders(outgoing);
@@ -20673,7 +21095,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 	}
 	else res = await res.catch(handleFetchError);
 	if (cacheKey in res) return responseViaCache(res, outgoing);
-	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+	const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? void 0 : defaultContentType);
 	if (res.body) {
 		const reader = res.body.getReader();
 		const values = [];
@@ -20713,7 +21135,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 			if (values.length === 0) flushHeaders(outgoing);
 			await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
 		}
-	} else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
+	} else if (resHeaderRecord["x-hono-already-sent"]) {} else {
 		outgoing.writeHead(res.status, resHeaderRecord);
 		outgoing.end();
 	}
@@ -20723,47 +21145,45 @@ var getRequestListener = (fetchCallback, options = {}) => {
 	const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
 	if (options.overrideGlobalObjects !== false && global.Request !== Request$1) {
 		Object.defineProperty(global, "Request", { value: Request$1 });
-		Object.defineProperty(global, "Response", { value: Response2 });
+		Object.defineProperty(global, "Response", { value: Response$1 });
 	}
 	return async (incoming, outgoing) => {
 		let res, req;
+		let needsBodyCleanup = false;
+		let closeHandlerAttached = false;
+		const ensureCloseHandler = () => {
+			if (!req || closeHandlerAttached) return;
+			closeHandlerAttached = true;
+			outgoing.on("close", makeCloseHandler(req, incoming, outgoing, needsBodyCleanup));
+		};
 		try {
 			req = newRequest(incoming, options.hostname);
-			let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-			if (!incomingEnded) {
+			needsBodyCleanup = autoCleanupIncoming && !(incoming.method === "GET" || incoming.method === "HEAD");
+			if (needsBodyCleanup) {
 				incoming[wrapBodyStream] = true;
-				incoming.on("end", () => {
-					incomingEnded = true;
-				});
 				if (incoming instanceof Http2ServerRequest) outgoing[outgoingEnded] = () => {
-					if (!incomingEnded) setTimeout(() => {
-						if (!incomingEnded) setTimeout(() => {
-							drainIncoming(incoming);
+					if (!incoming.readableEnded) setTimeout(() => {
+						if (!incoming.readableEnded) setTimeout(() => {
+							incoming.destroy();
+							outgoing.destroy();
 						});
 					});
 				};
-				outgoing.on("finish", () => {
-					if (!incomingEnded) drainIncoming(incoming);
-				});
 			}
-			outgoing.on("close", () => {
-				if (req[abortControllerKey]) {
-					if (incoming.errored) req[abortControllerKey].abort(incoming.errored.toString());
-					else if (!outgoing.writableFinished) req[abortControllerKey].abort("Client connection prematurely closed.");
-				}
-				if (!incomingEnded) setTimeout(() => {
-					if (!incomingEnded) setTimeout(() => {
-						drainIncoming(incoming);
-					});
-				});
-			});
 			res = fetchCallback(req, {
 				incoming,
 				outgoing
 			});
-			if (cacheKey in res) return responseViaCache(res, outgoing);
+			if (!isPromise(res) && isImmediateCacheableResponse(res)) {
+				if (needsBodyCleanup && !incoming.readableEnded) outgoing.once("finish", () => {
+					if (!incoming.readableEnded) drainIncoming(incoming);
+				});
+				return responseViaCache(res, outgoing);
+			}
+			ensureCloseHandler();
 		} catch (e) {
 			if (!res) if (options.errorHandler) {
+				ensureCloseHandler();
 				res = await options.errorHandler(req ? e : toRequestError(e));
 				if (!res) return;
 			} else if (!req) res = handleRequestError();
@@ -20777,6 +21197,160 @@ var getRequestListener = (fetchCallback, options = {}) => {
 		}
 	};
 };
+/**
+* @link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
+*/
+var CloseEvent$1 = globalThis.CloseEvent ?? class extends Event {
+	#eventInitDict;
+	constructor(type, eventInitDict = {}) {
+		super(type, eventInitDict);
+		this.#eventInitDict = eventInitDict;
+	}
+	get wasClean() {
+		return this.#eventInitDict.wasClean ?? false;
+	}
+	get code() {
+		return this.#eventInitDict.code ?? 0;
+	}
+	get reason() {
+		return this.#eventInitDict.reason ?? "";
+	}
+};
+var generateConnectionSymbol$1 = () => Symbol("connection");
+var CONNECTION_SYMBOL_KEY$1 = Symbol("CONNECTION_SYMBOL_KEY");
+var WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");
+var rejectUpgradeRequest = (socket, status) => {
+	socket.end(`HTTP/1.1 ${status.toString()} ${STATUS_CODES[status] ?? ""}\r\nConnection: close\r
+Content-Length: 0\r
+\r
+`);
+};
+var createUpgradeRequest = (request) => {
+	const protocol = request.socket.encrypted ? "https" : "http";
+	const url = new URL(request.url ?? "/", `${protocol}://${request.headers.host ?? "localhost"}`);
+	const headers = new Headers();
+	for (const key in request.headers) {
+		const value = request.headers[key];
+		if (!value) continue;
+		headers.append(key, Array.isArray(value) ? value[0] : value);
+	}
+	return new Request(url, { headers });
+};
+var setupWebSocket = (options) => {
+	const { server, fetchCallback, wss } = options;
+	const waiterMap = /* @__PURE__ */ new Map();
+	wss.on("connection", (ws, request) => {
+		const waiter = waiterMap.get(request);
+		if (waiter) {
+			waiter.resolve(ws);
+			waiterMap.delete(request);
+		}
+	});
+	const waitForWebSocket = (request, connectionSymbol) => {
+		return new Promise((resolve) => {
+			waiterMap.set(request, {
+				resolve,
+				connectionSymbol
+			});
+		});
+	};
+	server.on("upgrade", async (request, socket, head) => {
+		if (request.headers.upgrade?.toLowerCase() !== "websocket") return;
+		const env = {
+			incoming: request,
+			outgoing: void 0,
+			wss,
+			[WAIT_FOR_WEBSOCKET_SYMBOL]: waitForWebSocket
+		};
+		let status = 400;
+		try {
+			const response = await fetchCallback(createUpgradeRequest(request), env);
+			if (response instanceof Response) status = response.status;
+		} catch {
+			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, 500);
+			return;
+		}
+		const waiter = waiterMap.get(request);
+		if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY$1]) {
+			waiterMap.delete(request);
+			if (server.listenerCount("upgrade") === 1) rejectUpgradeRequest(socket, status);
+			return;
+		}
+		wss.handleUpgrade(request, socket, head, (ws) => {
+			wss.emit("connection", ws, request);
+		});
+	});
+	server.on("close", () => {
+		wss.close();
+	});
+};
+defineWebSocketHelper(async (c, events, options) => {
+	if (c.req.header("upgrade")?.toLowerCase() !== "websocket") return;
+	const env = c.env;
+	const waitForWebSocket = env[WAIT_FOR_WEBSOCKET_SYMBOL];
+	if (!waitForWebSocket || !env.incoming) return new Response(null, { status: 500 });
+	const connectionSymbol = generateConnectionSymbol$1();
+	env[CONNECTION_SYMBOL_KEY$1] = connectionSymbol;
+	(async () => {
+		const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+		const messagesReceivedInStarting = [];
+		const bufferMessage = (data, isBinary) => {
+			messagesReceivedInStarting.push([data, isBinary]);
+		};
+		ws.on("message", bufferMessage);
+		const ctx = {
+			binaryType: "arraybuffer",
+			close(code, reason) {
+				ws.close(code, reason);
+			},
+			protocol: ws.protocol,
+			raw: ws,
+			get readyState() {
+				return ws.readyState;
+			},
+			send(source, opts) {
+				ws.send(source, { compress: opts?.compress });
+			},
+			url: new URL(c.req.url)
+		};
+		try {
+			events?.onOpen?.(new Event("open"), ctx);
+		} catch (e) {
+			(options?.onError ?? console.error)(e);
+		}
+		const handleMessage = (data, isBinary) => {
+			const datas = Array.isArray(data) ? data : [data];
+			for (const data of datas) try {
+				events?.onMessage?.(new MessageEvent("message", { data: isBinary ? data instanceof ArrayBuffer ? data : data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength) : data.toString("utf-8") }), ctx);
+			} catch (e) {
+				(options?.onError ?? console.error)(e);
+			}
+		};
+		ws.off("message", bufferMessage);
+		for (const message of messagesReceivedInStarting) handleMessage(...message);
+		ws.on("message", (data, isBinary) => {
+			handleMessage(data, isBinary);
+		});
+		ws.on("close", (code, reason) => {
+			try {
+				events?.onClose?.(new CloseEvent$1("close", {
+					code,
+					reason: reason.toString()
+				}), ctx);
+			} catch (e) {
+				(options?.onError ?? console.error)(e);
+			}
+		});
+		ws.on("error", (error) => {
+			try {
+				events?.onError?.(new ErrorEvent("error", { error }), ctx);
+			} catch (e) {
+				(options?.onError ?? console.error)(e);
+			}
+		});
+	})();
+	return new Response();
+});
 var createAdaptorServer = (options) => {
 	const fetchCallback = options.fetch;
 	const requestListener = getRequestListener(fetchCallback, {
@@ -20784,7 +21358,16 @@ var createAdaptorServer = (options) => {
 		overrideGlobalObjects: options.overrideGlobalObjects,
 		autoCleanupIncoming: options.autoCleanupIncoming
 	});
-	return (options.createServer || createServer)(options.serverOptions || {}, requestListener);
+	const server = (options.createServer || createServer)(options.serverOptions || {}, requestListener);
+	if (options.websocket && options.websocket.server) {
+		if (options.websocket.server.options.noServer !== true) throw new Error("WebSocket server must be created with { noServer: true } option");
+		setupWebSocket({
+			server,
+			fetchCallback,
+			wss: options.websocket.server
+		});
+	}
+	return server;
 };
 var serve = (options, listeningListener) => {
 	const server = createAdaptorServer(options);
@@ -21083,6 +21666,8 @@ var ActionName = /* @__PURE__ */ function(ActionName) {
 	ActionName["SetDoubtFriendsAddRequest"] = "set_doubt_friends_add_request";
 	ActionName["DeleteGroupNotice"] = "_delete_group_notice";
 	ActionName["SendPoke"] = "send_poke";
+	ActionName["SetInputStatus"] = "set_input_status";
+	ActionName["GetGroupAlbumMediaList"] = "get_group_album_media_list";
 	ActionName["SendLike"] = "send_like";
 	ActionName["GetLoginInfo"] = "get_login_info";
 	ActionName["GetFriendList"] = "get_friend_list";
@@ -21159,15 +21744,24 @@ var GetMsg = class extends BaseAction {
 	async _handle(payload, config) {
 		const msgInfo = await this.ctx.store.getMsgInfoByShortId(+payload.message_id);
 		if (!msgInfo) throw new Error("消息不存在");
-		let msg = this.ctx.store.getMsgCache(msgInfo.msgId);
-		if (!msg) {
-			const res = await this.ctx.ntMsgApi.getMsgsByMsgId(msgInfo.peer, [msgInfo.msgId]);
-			if (res.msgList.length === 0) throw new Error("无法获取该消息");
-			msg = res.msgList[0];
-		}
+		let status = "normal";
+		let msg;
+		const res = await this.ctx.ntMsgApi.getMsgsByMsgId(msgInfo.peer, [msgInfo.msgId]);
+		if (res.msgList.length === 0 || res.msgList[0].elements[0].grayTipElement?.revokeElement) {
+			const msgCache = this.ctx.store.getMsgCache(msgInfo.msgId);
+			if (msgCache) {
+				msg = msgCache;
+				status = "deleted";
+			} else if (res.msgList.length === 0) throw new Error("无法获取该消息");
+			else {
+				msg = res.msgList[0];
+				status = "deleted";
+			}
+		} else msg = res.msgList[0];
 		const retMsg = await OB11Entities.message(this.ctx, msg, void 0, void 0, config);
 		if (!retMsg) throw new Error("消息为空");
 		retMsg.real_id = retMsg.message_seq;
+		retMsg.status = status;
 		return retMsg;
 	}
 };
@@ -23260,7 +23854,8 @@ var MessageEncoder$1 = class MessageEncoder$1 {
 		"forward",
 		"node",
 		"video",
-		"file"
+		"file",
+		"at"
 	];
 	results;
 	children;
@@ -23291,7 +23886,7 @@ var MessageEncoder$1 = class MessageEncoder$1 {
 	}
 	async flush() {
 		if (this.children.length === 0 && !this.content) return;
-		const nick = this.name || selfInfo.nick || "QQ用户";
+		const nick = this.name ?? selfInfo.nick;
 		if (this.news.length < 4) this.news.push({ text: `${nick}: ${this.preview}` });
 		this.results.push({
 			routingHead: {
@@ -23537,7 +24132,7 @@ var MessageEncoder$1 = class MessageEncoder$1 {
 				} });
 			} else {
 				const data = await this.ctx.ntFileApi.uploadC2CFile(this.peer.peerUid, path, fileName);
-				this.content = Msg.FileExtra.encode({ file: {
+				const extra = Msg.FileExtra.encode({ file: {
 					fileType: 0,
 					fileUuid: data.fileId,
 					fileMd5: data.file10MMd5,
@@ -23548,8 +24143,25 @@ var MessageEncoder$1 = class MessageEncoder$1 {
 					expireTime: Math.floor(Date.now() / 1e3 + 10080 * 60),
 					fileIdCrcMedia: data.crcMedia
 				} });
+				this.content = extra;
 			}
 			this.preview += `[文件] ${fileName}`;
+		} else if (type === OB11MessageDataType.At) {
+			if (!this.isGroup) return;
+			let str;
+			if (isNonNullable(data.name)) str = `@${data.name}`;
+			else if (data.qq === "all") str = "@全体成员";
+			else {
+				const uid = await this.ctx.ntUserApi.getUidByUin(data.qq, this.isGroup ? this.peer.peerUid : void 0);
+				try {
+					const info = await this.ctx.ntGroupApi.getGroupMember(this.peer.peerUid, uid, false, 50);
+					str = `@${info.cardName || info.nick}`;
+				} catch (e) {
+					str = `@${(await this.ctx.ntUserApi.getUserSimpleInfo(uid)).coreInfo.nick}`;
+				}
+			}
+			this.children.push({ text: { str } });
+			this.preview += str;
 		}
 	}
 	async render(segments) {
@@ -25904,6 +26516,43 @@ var SendPoke = class extends BaseAction {
 	}
 };
 //#endregion
+//#region src/onebot11/action/llbot/user/SetInputStatus.ts
+var SetInputStatus = class extends BaseAction {
+	actionName = ActionName.SetInputStatus;
+	payloadSchema = lib_default$1.object({
+		user_id: lib_default$1.union([Number, String]).required(),
+		event_type: lib_default$1.union([Number, String]).required()
+	});
+	async _handle(payload) {
+		const uin = payload.user_id.toString();
+		const uid = await this.ctx.ntUserApi.getUidByUin(uin);
+		if (!uid) throw new Error("无法获取用户信息");
+		const result = await this.ctx.ntMsgApi.sendShowInputStatusReq(ChatType.C2C, +payload.event_type, uid);
+		if (result.result !== 0) throw new Error(result.errMsg);
+		return null;
+	}
+};
+//#endregion
+//#region src/onebot11/action/llbot/group/GroupAlbum/GetGroupAlbumMediaList.ts
+var GetGroupAlbumMediaList = class extends BaseAction {
+	actionName = ActionName.GetGroupAlbumMediaList;
+	payloadSchema = lib_default$1.object({
+		group_id: lib_default$1.union([Number, String]).required(),
+		album_id: lib_default$1.string().required(),
+		attach_info: lib_default$1.string()
+	});
+	async _handle(payload) {
+		const res = await this.ctx.ntGroupApi.getGroupAlbumMediaList(payload.group_id.toString(), payload.album_id, payload.attach_info);
+		if (res.response.result !== 0) throw new Error(res.response.errMs);
+		return pick(res.response, [
+			"album",
+			"media_list",
+			"next_attach_info",
+			"next_has_more"
+		]);
+	}
+};
+//#endregion
 //#region src/onebot11/action/index.ts
 function initActionMap(adapter) {
 	const actionHandlers = [
@@ -25957,6 +26606,8 @@ function initActionMap(adapter) {
 		new SetDoubtFriendsAddRequest(adapter),
 		new DeleteGroupNotice(adapter),
 		new SendPoke(adapter),
+		new SetInputStatus(adapter),
+		new GetGroupAlbumMediaList(adapter),
 		new SendLike(adapter),
 		new GetMsg(adapter),
 		new GetLoginInfo$1(adapter),
@@ -26203,7 +26854,8 @@ var Onebot11Adapter = class extends Service {
 		"app",
 		"logger",
 		"pmhq",
-		"timer"
+		"timer",
+		"config"
 	];
 	connect;
 	actionMap;
@@ -28215,27 +28867,6 @@ var handlers = {
 	deleteFriend
 };
 //#endregion
-//#region node_modules/hono/dist/helper/websocket/index.js
-var defineWebSocketHelper = (handler) => {
-	return ((...args) => {
-		if (typeof args[0] === "function") {
-			const [createEvents, options] = args;
-			return async function upgradeWebSocket(c, next) {
-				const result = await handler(c, await createEvents(c), options);
-				if (result) return result;
-				await next();
-			};
-		} else {
-			const [c, events, options] = args;
-			return (async () => {
-				const upgraded = await handler(c, events, options);
-				if (!upgraded) throw new Error("Failed to upgrade WebSocket");
-				return upgraded;
-			})();
-		}
-	});
-};
-//#endregion
 //#region node_modules/@hono/node-ws/dist/index.js
 /**
 * @link https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent
@@ -43258,7 +43889,7 @@ var ForwardMessageEncoder = class ForwardMessageEncoder {
 	}
 	async flush() {
 		if (this.children.length === 0) return;
-		const nick = this.name || selfInfo.nick || "QQ用户";
+		const nick = this.name ?? selfInfo.nick;
 		if (this.news.length < 4) this.news.push({ text: `${nick}: ${this.preview}` });
 		this.results.push({
 			routingHead: {
@@ -45776,7 +46407,7 @@ function getIgnoreAttributesFn(ignoreAttributes) {
 	return () => false;
 }
 //#endregion
-//#region node_modules/path-expression-matcher/src/Expression.js
+//#region node_modules/fast-xml-parser/node_modules/path-expression-matcher/src/Expression.js
 /**
 * Expression - Parses and stores a tag pattern expression
 * 
@@ -45928,7 +46559,7 @@ var Expression = class {
 	}
 };
 //#endregion
-//#region node_modules/path-expression-matcher/src/ExpressionSet.js
+//#region node_modules/fast-xml-parser/node_modules/path-expression-matcher/src/ExpressionSet.js
 /**
 * ExpressionSet - An indexed collection of Expressions for efficient bulk matching
 *
@@ -46101,7 +46732,7 @@ var ExpressionSet = class {
 	}
 };
 //#endregion
-//#region node_modules/path-expression-matcher/src/Matcher.js
+//#region node_modules/fast-xml-parser/node_modules/path-expression-matcher/src/Matcher.js
 /**
 * MatcherView - A lightweight read-only view over a Matcher's internal state.
 *
@@ -47289,11 +47920,7 @@ async function transformIncomingSegments(ctx, message) {
 				type: "video",
 				data: {
 					resource_id: element.videoElement.fileUuid,
-					temp_url: await ctx.ntFileApi.getVideoUrl({
-						chatType: message.chatType,
-						peerUid: message.peerUid,
-						guildId: message.guildId
-					}, message.msgId, element.elementId),
+					temp_url: await ctx.ntFileApi.getVideoUrlByPacket(element.videoElement.fileUuid, message.chatType === ChatType.Group),
 					width: element.videoElement.thumbWidth,
 					height: element.videoElement.thumbHeight,
 					duration: element.videoElement.fileTime
@@ -52297,7 +52924,7 @@ var NTQQFileApi = class extends Service {
 			const trans = {
 				uin: selfInfo.uin,
 				cmd: 1005,
-				readable: createReadStream$1(filePath, { highWaterMark: maxBlockSize }),
+				readable: createReadStream(filePath, { highWaterMark: maxBlockSize }),
 				sum: Buffer.from(index.info.md5HexStr, "hex"),
 				size: index.info.fileSize,
 				ticket: highwaySession.sigSession,
@@ -52317,7 +52944,7 @@ var NTQQFileApi = class extends Service {
 			const trans = {
 				uin: selfInfo.uin,
 				cmd: 1006,
-				readable: createReadStream$1(thumbPath, { highWaterMark: maxBlockSize }),
+				readable: createReadStream(thumbPath, { highWaterMark: maxBlockSize }),
 				sum: Buffer.from(index.info.md5HexStr, "hex"),
 				size: index.info.fileSize,
 				ticket: highwaySession.sigSession,
@@ -52346,7 +52973,7 @@ var NTQQFileApi = class extends Service {
 			const trans = {
 				uin: selfInfo.uin,
 				cmd: 1001,
-				readable: createReadStream$1(filePath, { highWaterMark: maxBlockSize }),
+				readable: createReadStream(filePath, { highWaterMark: maxBlockSize }),
 				sum: Buffer.from(index.info.md5HexStr, "hex"),
 				size: index.info.fileSize,
 				ticket: highwaySession.sigSession,
@@ -52366,7 +52993,7 @@ var NTQQFileApi = class extends Service {
 			const trans = {
 				uin: selfInfo.uin,
 				cmd: 1002,
-				readable: createReadStream$1(thumbPath, { highWaterMark: maxBlockSize }),
+				readable: createReadStream(thumbPath, { highWaterMark: maxBlockSize }),
 				sum: Buffer.from(index.info.md5HexStr, "hex"),
 				size: index.info.fileSize,
 				ticket: highwaySession.sigSession,
@@ -52425,7 +53052,7 @@ var NTQQFileApi = class extends Service {
 			const trans = {
 				uin: selfInfo.uin,
 				cmd: 71,
-				readable: createReadStream$1(filePath, { highWaterMark: 1024 * 1024 }),
+				readable: createReadStream(filePath, { highWaterMark: 1024 * 1024 }),
 				sum: result.md5,
 				size: result.fileSize,
 				ticket: highwaySession.sigSession,
@@ -52482,7 +53109,7 @@ var NTQQFileApi = class extends Service {
 		const trans = {
 			uin: selfInfo.uin,
 			cmd: 95,
-			readable: createReadStream$1(filePath, { highWaterMark: 1024 * 1024 }),
+			readable: createReadStream(filePath, { highWaterMark: 1024 * 1024 }),
 			sum: result.md5CheckSum,
 			size: result.fileSize,
 			ticket: highwaySession.sigSession,
@@ -52636,7 +53263,7 @@ var NTQQGroupApi = class extends Service {
 	async getGroupMembers(groupCode, forceFetch = true) {
 		return await this.ctx.pmhq.invoke(NTMethod.GROUP_MEMBERS, [groupCode, forceFetch]);
 	}
-	async getGroupMember(groupCode, uid, forceUpdate = false) {
+	async getGroupMember(groupCode, uid, forceUpdate = false, timeout = 15e3) {
 		return (await this.ctx.pmhq.invoke("nodeIKernelGroupService/getMemberInfo", [
 			groupCode,
 			[uid],
@@ -52645,7 +53272,8 @@ var NTQQGroupApi = class extends Service {
 			resultCmd: "nodeIKernelGroupListener/onMemberInfoChange",
 			resultCb: (result) => {
 				return result[0] === groupCode && result[2].has(uid);
-			}
+			},
+			timeout
 		}))[2].get(uid);
 	}
 	async getSingleScreenNotifies(doubt, number, startSeq = "") {
@@ -52871,7 +53499,7 @@ var NTQQGroupApi = class extends Service {
 	async getGroupShutUpMemberList(groupCode) {
 		return (await this.ctx.pmhq.invoke("nodeIKernelGroupService/getGroupShutUpMemberList", [groupCode], {
 			resultCmd: "nodeIKernelGroupListener/onShutUpMemberListChanged",
-			resultCb: (payload) => payload[0] === groupCode
+			resultCb: (payload) => payload[0] === groupCode || payload[0] === "0"
 		}))[1];
 	}
 	async renameGroupFolder(groupId, folderId, newFolderName) {
@@ -52939,6 +53567,17 @@ var NTQQGroupApi = class extends Service {
 			}
 		});
 	}
+	async getGroupAlbumMediaList(groupCode, albumId, attachInfo = "") {
+		return await this.ctx.pmhq.invoke("nodeIKernelAlbumService/getMediaList", [{
+			qun_id: groupCode,
+			attach_info: attachInfo,
+			seq: 0,
+			request_time_line: { request_invoke_time: "0" },
+			album_id: albumId,
+			lloc: "",
+			batch_id: ""
+		}]);
+	}
 };
 //#endregion
 //#region src/ntqqapi/api/login.ts
@@ -53307,6 +53946,13 @@ var NTQQMsgApi = class extends Service {
 	async setContactLocalTop(peer, isTop) {
 		return await this.ctx.pmhq.invoke("nodeIKernelMsgService/setContactLocalTop", [peer, isTop]);
 	}
+	async sendShowInputStatusReq(chatType, eventType, toUid) {
+		return await this.ctx.pmhq.invoke("nodeIKernelMsgService/sendShowInputStatusReq", [
+			chatType,
+			eventType,
+			toUid
+		]);
+	}
 };
 //#endregion
 //#region src/common/utils/request.ts
@@ -56782,7 +57428,7 @@ var tryDecodeURI = (str) => tryDecode(str, decodeURI);
 var serveStatic = (options = { root: "" }) => {
 	const root = options.root || "";
 	const optionPath = options.path;
-	if (root !== "" && !existsSync(root)) console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
+	if (root !== "" && !existsSync$1(root)) console.error(`serveStatic: root path '${root}' is not found, are you sure it's correct?`);
 	return async (c, next) => {
 		if (c.finalized) return next();
 		let filename;
@@ -60869,7 +61515,19 @@ var require_punycode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		});
 	};
 	module.exports = {
+		/**
+		* A string representing the current Punycode.js version number.
+		* @memberOf punycode
+		* @type String
+		*/
 		version: "2.3.1",
+		/**
+		* An object of methods to convert from JavaScript's internal character
+		* representation (UCS-2) to Unicode code points, and back.
+		* @see <https://mathiasbynens.be/notes/javascript-encoding>
+		* @memberOf punycode
+		* @type Object
+		*/
 		ucs2: {
 			decode: ucs2decode,
 			encode: ucs2encode
@@ -61142,13 +61800,38 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var qp = require_qp();
 	var mimeTypes = require_mime_types();
 	module.exports = {
+		/**
+		* Checks if a value is plaintext string (uses only printable 7bit chars)
+		*
+		* @param {String} value String to be tested
+		* @returns {Boolean} true if it is a plaintext string
+		*/
 		isPlainText(value, isParam) {
 			return typeof value === "string" && !(isParam ? /[\x00-\x08\x0b\x0c\x0e-\x1f"\u0080-\uFFFF]/ : /[\x00-\x08\x0b\x0c\x0e-\x1f\u0080-\uFFFF]/).test(value);
 		},
+		/**
+		* Checks if a multi line string containes lines longer than the selected value.
+		*
+		* Useful when detecting if a mail message needs any processing at all –
+		* if only plaintext characters are used and lines are short, then there is
+		* no need to encode the values in any way. If the value is plaintext but has
+		* longer lines then allowed, then use format=flowed
+		*
+		* @param {Number} lineLength Max line length to check for
+		* @returns {Boolean} Returns true if there is at least one line longer than lineLength chars
+		*/
 		hasLongerLines(str, lineLength) {
 			if (str.length > 128 * 1024) return true;
 			return new RegExp("^.{" + (lineLength + 1) + ",}", "m").test(str);
 		},
+		/**
+		* Encodes a string or an Buffer to an UTF-8 MIME Word (rfc2047)
+		*
+		* @param {String|Buffer} data String to be encoded
+		* @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+		* @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+		* @return {String} Single or several mime words joined together
+		*/
 		encodeWord(data, mimeWordEncoding, maxLength) {
 			mimeWordEncoding = (mimeWordEncoding || "Q").toString().toUpperCase().trim().charAt(0);
 			maxLength = maxLength || 0;
@@ -61184,6 +61867,15 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			else if (mimeWordEncoding === "B") encodedStr = base64.encode(data);
 			return "=?" + toCharset + "?" + mimeWordEncoding + "?" + encodedStr + (encodedStr.substr(-2) === "?=" ? "" : "?=");
 		},
+		/**
+		* Finds word sequences with non ascii text and converts these to mime words
+		*
+		* @param {String} value String to be encoded
+		* @param {String} mimeWordEncoding='Q' Encoding for the mime word, either Q or B
+		* @param {Number} [maxLength=0] If set, split mime words into several chunks if needed
+		* @param {Boolean} [encodeAll=false] If true and the value needs encoding then encodes entire string, not just the smallest match
+		* @return {String} String with possible mime words
+		*/
 		encodeWords(value, mimeWordEncoding, maxLength, encodeAll) {
 			maxLength = maxLength || 0;
 			const firstMatch = value.match(/(?:^|\s)([^\s]*["\u0080-\uFFFF])/);
@@ -61195,6 +61887,13 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			const endIndex = lastMatch.index + (lastMatch[1] || "").length;
 			return (startIndex ? value.substr(0, startIndex) : "") + this.encodeWord(value.substring(startIndex, endIndex), mimeWordEncoding || "Q", maxLength) + (endIndex < value.length ? value.substr(endIndex) : "");
 		},
+		/**
+		* Joins parsed header value together as 'value; param1=value1; param2=value2'
+		* PS: We are following RFC 822 for the list of special characters that we need to keep in quotes.
+		*      Refer: https://www.w3.org/Protocols/rfc1341/4_Content-Type.html
+		* @param {Object} structured Parsed header value
+		* @return {String} joined header value
+		*/
 		buildHeaderValue(structured) {
 			const paramsArray = [];
 			Object.keys(structured.params || {}).forEach((param) => {
@@ -61208,6 +61907,21 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			});
 			return structured.value + (paramsArray.length ? "; " + paramsArray.join("; ") : "");
 		},
+		/**
+		* Encodes a string or an Buffer to an UTF-8 Parameter Value Continuation encoding (rfc2231)
+		* Useful for splitting long parameter values.
+		*
+		* For example
+		*      title="unicode string"
+		* becomes
+		*     title*0*=utf-8''unicode
+		*     title*1*=%20string
+		*
+		* @param {String|Buffer} data String to be encoded
+		* @param {Number} [maxLength=50] Max length for generated chunks
+		* @param {String} [fromCharset='UTF-8'] Source sharacter set
+		* @return {Array} A list of encoded keys and headers
+		*/
 		buildHeaderParam(key, data, maxLength) {
 			const list = [];
 			let encodedStr = typeof data === "string" ? data : (data || "").toString();
@@ -61284,6 +61998,21 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				value: item.line
 			}));
 		},
+		/**
+		* Parses a header value with key=value arguments into a structured
+		* object.
+		*
+		*   parseHeaderValue('content-type: text/plain; CHARSET='UTF-8'') ->
+		*   {
+		*     'value': 'text/plain',
+		*     'params': {
+		*       'charset': 'UTF-8'
+		*     }
+		*   }
+		*
+		* @param {String} str Header value
+		* @return {Object} Header value as a parsed structure
+		*/
 		parseHeaderValue(str) {
 			const response = {
 				value: false,
@@ -61356,8 +62085,31 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			});
 			return response;
 		},
+		/**
+		* Returns file extension for a content type string. If no suitable extensions
+		* are found, 'bin' is used as the default extension
+		*
+		* @param {String} mimeType Content type to be checked for
+		* @return {String} File extension
+		*/
 		detectExtension: (mimeType) => mimeTypes.detectExtension(mimeType),
+		/**
+		* Returns content type for a file extension. If no suitable content types
+		* are found, 'application/octet-stream' is used as the default content type
+		*
+		* @param {String} extension Extension to be checked for
+		* @return {String} File extension
+		*/
 		detectMimeType: (extension) => mimeTypes.detectMimeType(extension),
+		/**
+		* Folds long lines, useful for folding header lines (afterSpace=false) and
+		* flowed text (afterSpace=true)
+		*
+		* @param {String} str String to be folded
+		* @param {Number} [lineLength=76] Maximum length of a line
+		* @param {Boolean} afterSpace If true, leave a space in th end of a line
+		* @return {String} String with folded lines
+		*/
 		foldLines(str, lineLength, afterSpace) {
 			str = (str || "").toString();
 			lineLength = lineLength || 76;
@@ -61384,6 +62136,13 @@ var require_mime_funcs = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 			return result;
 		},
+		/**
+		* Splits a mime encoded string. Needed for dividing mime words into smaller chunks
+		*
+		* @param {String} str Mime encoded string to be split up
+		* @param {Number} maxlen Maximum length of characters for one part (minimum 12)
+		* @return {Array} Split string
+		*/
 		splitMimeEncodedString: (str, maxlen) => {
 			const lines = [];
 			let curLine, match, chr, done;
@@ -61799,7 +62558,7 @@ var require_le_unix = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 //#endregion
 //#region node_modules/nodemailer/lib/mime-node/index.js
 var require_mime_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-	var crypto$9 = __require("crypto");
+	var crypto$8 = __require("crypto");
 	var fs$4 = __require("fs");
 	var punycode = require_punycode();
 	var { PassThrough: PassThrough$2 } = __require("stream");
@@ -61830,7 +62589,7 @@ var require_mime_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			/**
 			* shared part of the unique multipart boundary
 			*/
-			this.baseBoundary = options.baseBoundary || crypto$9.randomBytes(8).toString("hex");
+			this.baseBoundary = options.baseBoundary || crypto$8.randomBytes(8).toString("hex");
 			this.boundaryPrefix = options.boundaryPrefix || "--_NmP";
 			this.disableFileAccess = !!options.disableFileAccess;
 			this.disableUrlAccess = !!options.disableUrlAccess;
@@ -62717,7 +63476,7 @@ var require_mime_node = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				2,
 				2,
 				6
-			].reduce((prev, len) => prev + "-" + crypto$9.randomBytes(len).toString("hex"), crypto$9.randomBytes(4).toString("hex")) + "@" + (this.getEnvelope().from || this.hostname || "localhost").split("@").pop() + ">";
+			].reduce((prev, len) => prev + "-" + crypto$8.randomBytes(len).toString("hex"), crypto$8.randomBytes(4).toString("hex")) + "@" + (this.getEnvelope().from || this.hostname || "localhost").split("@").pop() + ">";
 		}
 	};
 }));
@@ -63182,14 +63941,14 @@ var require_message_parser = /* @__PURE__ */ __commonJSMin(((exports, module) =>
 //#region node_modules/nodemailer/lib/dkim/relaxed-body.js
 var require_relaxed_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var { Transform: Transform$2 } = __require("stream");
-	var crypto$8 = __require("crypto");
+	var crypto$7 = __require("crypto");
 	var RelaxedBody = class extends Transform$2 {
 		constructor(options) {
 			super();
 			options = options || {};
 			this.chunkBuffer = [];
 			this.chunkBufferLen = 0;
-			this.bodyHash = crypto$8.createHash(options.hashAlgo || "sha1");
+			this.bodyHash = crypto$7.createHash(options.hashAlgo || "sha1");
 			this.remainder = "";
 			this.byteLength = 0;
 			this.debug = options.debug;
@@ -63268,7 +64027,7 @@ var require_relaxed_body = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 var require_sign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var punycode = require_punycode();
 	var mimeFuncs = require_mime_funcs();
-	var crypto$7 = __require("crypto");
+	var crypto$6 = __require("crypto");
 	/**
 	* Returns DKIM signature header line
 	*
@@ -63285,7 +64044,7 @@ var require_sign = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		const canonicalizedHeaderData = relaxedHeaders(headers, options.headerFieldNames || "From:Sender:Reply-To:Subject:Date:Message-ID:To:Cc:MIME-Version:Content-Type:Content-Transfer-Encoding:Content-ID:Content-Description:Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:In-Reply-To:References:List-Id:List-Help:List-Unsubscribe:List-Subscribe:List-Post:List-Owner:List-Archive", options.skipFields);
 		const dkimHeader = generateDKIMHeader(options.domainName, options.keySelector, canonicalizedHeaderData.fieldNames, hashAlgo, bodyHash);
 		canonicalizedHeaderData.headers += "dkim-signature:" + relaxedHeaderLine(dkimHeader);
-		const signer = crypto$7.createSign(("rsa-" + hashAlgo).toUpperCase());
+		const signer = crypto$6.createSign(("rsa-" + hashAlgo).toUpperCase());
 		signer.update(canonicalizedHeaderData.headers);
 		let signature;
 		try {
@@ -63349,7 +64108,7 @@ var require_dkim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var { PassThrough: PassThrough$1 } = __require("stream");
 	var fs$3 = __require("fs");
 	var path$2 = __require("path");
-	var crypto$6 = __require("crypto");
+	var crypto$5 = __require("crypto");
 	var DKIM_ALGO = "sha256";
 	var MAX_MESSAGE_SIZE = 2 * 1024 * 1024;
 	var DKIMSigner = class {
@@ -63362,7 +64121,7 @@ var require_dkim = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			this.chunks = [];
 			this.chunklen = 0;
 			this.readPos = 0;
-			this.cachePath = this.cacheDir ? path$2.join(this.cacheDir, "message." + Date.now() + "-" + crypto$6.randomBytes(14).toString("hex")) : false;
+			this.cachePath = this.cacheDir ? path$2.join(this.cacheDir, "message." + Date.now() + "-" + crypto$5.randomBytes(14).toString("hex")) : false;
 			this.cache = false;
 			this.headers = false;
 			this.bodyHash = false;
@@ -63821,7 +64580,7 @@ var require_mailer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var MailMessage = require_mail_message();
 	var net$2 = __require("net");
 	var dns = __require("dns");
-	var crypto$5 = __require("crypto");
+	var crypto$4 = __require("crypto");
 	/**
 	* Creates an object for exposing the Mail API
 	*
@@ -64070,7 +64829,7 @@ var require_mailer = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 				if (err) return callback(err);
 				let cidCounter = 0;
 				html = (html || "").toString().replace(/(<img\b[^<>]{0,1024} src\s{0,20}=[\s"']{0,20})(data:([^;]+);[^"'>\s]+)/gi, (match, prefix, dataUri, mimeType) => {
-					const cid = crypto$5.randomBytes(10).toString("hex") + "@localhost";
+					const cid = crypto$4.randomBytes(10).toString("hex") + "@localhost";
 					if (!mail.data.attachments) mail.data.attachments = [];
 					if (!Array.isArray(mail.data.attachments)) mail.data.attachments = [].concat(mail.data.attachments || []);
 					mail.data.attachments.push({
@@ -64179,7 +64938,7 @@ var require_smtp_connection = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	var net$1 = __require("net");
 	var tls = __require("tls");
 	var os$1 = __require("os");
-	var crypto$4 = __require("crypto");
+	var crypto$3 = __require("crypto");
 	var DataStream = require_data_stream();
 	var { PassThrough } = __require("stream");
 	var shared = require_shared();
@@ -64234,7 +64993,7 @@ var require_smtp_connection = /* @__PURE__ */ __commonJSMin(((exports, module) =
 	var SMTPConnection = class extends EventEmitter$4 {
 		constructor(options) {
 			super(options);
-			this.id = crypto$4.randomBytes(8).toString("base64").replace(/\W/g, "");
+			this.id = crypto$3.randomBytes(8).toString("base64").replace(/\W/g, "");
 			this.stage = "init";
 			this.options = options || {};
 			this.secureConnection = !!this.options.secure;
@@ -65182,7 +65941,7 @@ var require_smtp_connection = /* @__PURE__ */ __commonJSMin(((exports, module) =
 			const challengeMatch = str.match(/^334\s+(.+)$/);
 			if (!challengeMatch) return callback(this._formatError("Invalid login sequence while waiting for server challenge string", "EAUTH", str, "AUTH CRAM-MD5"));
 			const base64decoded = Buffer.from(challengeMatch[1], "base64").toString("ascii");
-			const hmacMD5 = crypto$4.createHmac("md5", this._auth.credentials.pass);
+			const hmacMD5 = crypto$3.createHmac("md5", this._auth.credentials.pass);
 			hmacMD5.update(base64decoded);
 			const prepended = this._auth.credentials.user + " " + hmacMD5.digest("hex");
 			this._responseActions.push((str) => {
@@ -65408,7 +66167,7 @@ var require_smtp_connection = /* @__PURE__ */ __commonJSMin(((exports, module) =
 var require_xoauth2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var { Stream } = __require("stream");
 	var nmfetch = require_fetch();
-	var crypto$3 = __require("crypto");
+	var crypto$2 = __require("crypto");
 	var shared = require_shared();
 	var errors = require_errors();
 	/**
@@ -65724,7 +66483,7 @@ var require_xoauth2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		*/
 		jwtSignRS256(payload) {
 			payload = ["{\"alg\":\"RS256\",\"typ\":\"JWT\"}", JSON.stringify(payload)].map((val) => this.toBase64URL(val)).join(".");
-			const signature = crypto$3.createSign("RSA-SHA256").update(payload).sign(this.options.privateKey);
+			const signature = crypto$2.createSign("RSA-SHA256").update(payload).sign(this.options.privateKey);
 			return payload + "." + this.toBase64URL(signature);
 		}
 	};
@@ -68331,7 +69090,6 @@ var PMHQBase = class extends Service {
 		super(ctx, "pmhq");
 		this.ctx = ctx;
 		this.logger = ctx.logger("pmhq");
-		this.logger.info(process.argv);
 		const { pmhqHost, pmhqPort } = this.getPMHQHostPort();
 		this.httpUrl = `http://${pmhqHost}:${pmhqPort}/`;
 		this.wsUrl = `ws://${pmhqHost}:${pmhqPort}/ws`;
@@ -68589,6 +69347,15 @@ var PMHQBase = class extends Service {
 				});
 				this.call(funcName, args, timeout).then((r) => {
 					firstResult = r;
+					if (options.onCallResult) {
+						const result = options.onCallResult(r);
+						if (result !== void 0) {
+							resolve(result);
+							this.removeReceiveHook(hookId);
+							if (timeoutId) clearTimeout(timeoutId);
+							return;
+						}
+					}
 					if (r && Object.hasOwn(r, "result") && +r.result !== 0) {
 						const displayReq = inspect(args, {
 							depth: 10,
@@ -69670,7 +70437,7 @@ async function onLoad() {
 		ctx.plugin(EmailNotificationService);
 	};
 	const isDocker = isDockerEnvironment();
-	let qrCodeTriggered = false;
+	let lastQrCodeTime = 0;
 	const printLoginQrCode = async () => {
 		try {
 			const data = await ctx.ntLoginApi.getLoginQrCode();
@@ -69702,8 +70469,9 @@ async function onLoad() {
 			return;
 		}
 		if (!pmhqSelfInfo.online) {
-			if (isDocker && !qrCodeTriggered) {
-				qrCodeTriggered = true;
+			const now = Date.now();
+			if (isDocker && now - lastQrCodeTime > 12e4) {
+				lastQrCodeTime = now;
 				printLoginQrCode();
 			}
 			setTimeout(checkLogin, 1e3);
@@ -69732,6 +70500,7 @@ async function onLoad() {
 	ctx.inject(["logger"], (ctx) => {
 		ctx.logger.exporter(new Log(ctx, true));
 		ctx.logger.info(`LLBot ${version$2}`);
+		ctx.logger.info(process.argv);
 	});
 	ctx.inject([
 		"pmhq",