dsh-messager 0.1.4

package/lib/client.js

@@ -0,0 +1,2001 @@
+window.__ModuleLoader__.load({
+	id: "dsh-messager",
+	factory: (require) => {
+		var module = { exports: {} };
+		var exports = module.exports;
+		Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+		let react_jsx_runtime = require("react/jsx-runtime");
+		//#region node_modules/.pnpm/@deepseek-ai+cosmokit@1.8.2/node_modules/@deepseek-ai/cosmokit/lib/index.js
+		/** Return true when a value is `null` or `undefined`. */
+		function isNullable(value) {
+			return value === null || value === void 0;
+		}
+		/** Return true for non-array object values. */
+		function isPlainObject(data) {
+			return data && typeof data === "object" && !Array.isArray(data);
+		}
+		/** Filter object entries and return a new object. */
+		function filterKeys(object, filter) {
+			return Object.fromEntries(Object.entries(object).filter(([key, value]) => filter(key, value)));
+		}
+		/** Map object values while preserving the original key set. */
+		function mapValues(object, transform) {
+			return Object.fromEntries(Object.entries(object).map(([key, value]) => [key, transform(value, key)]));
+		}
+		/** Pick selected keys from an object, optionally including `undefined` values. */
+		function pick(source, keys, forced) {
+			if (!keys) return { ...source };
+			const result = {};
+			for (const key of keys) if (forced || source[key] !== void 0) result[key] = source[key];
+			return result;
+		}
+		/** Test values using `instanceof` with a `toStringTag` fallback. */
+		function is(type, value) {
+			if (arguments.length === 1) return (value) => is(type, value);
+			return type in globalThis && value instanceof globalThis[type] || Object.prototype.toString.call(value).slice(8, -1) === type;
+		}
+		function isArrayBufferLike(value) {
+			return is("ArrayBuffer", value) || is("SharedArrayBuffer", value);
+		}
+		function isArrayBufferSource(value) {
+			return isArrayBufferLike(value) || ArrayBuffer.isView(value);
+		}
+		/** Binary source detection and base64/hex conversion helpers. */
+		var Binary;
+		(function(Binary) {
+			Binary.is = isArrayBufferLike;
+			Binary.isSource = isArrayBufferSource;
+			function fromSource(source) {
+				if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+				else return source;
+			}
+			Binary.fromSource = fromSource;
+			function toBase64(source) {
+				source = fromSource(source);
+				if (typeof Buffer !== "undefined") return Buffer.from(source).toString("base64");
+				let binary = "";
+				const bytes = new Uint8Array(source);
+				for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+				return btoa(binary);
+			}
+			Binary.toBase64 = toBase64;
+			function fromBase64(source) {
+				if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "base64"));
+				return Uint8Array.from(atob(source), (c) => c.charCodeAt(0));
+			}
+			Binary.fromBase64 = fromBase64;
+			function toHex(source) {
+				source = fromSource(source);
+				if (typeof Buffer !== "undefined") return Buffer.from(source).toString("hex");
+				return Array.from(new Uint8Array(source), (byte) => byte.toString(16).padStart(2, "0")).join("");
+			}
+			Binary.toHex = toHex;
+			function fromHex(source) {
+				if (typeof Buffer !== "undefined") return fromSource(Buffer.from(source, "hex"));
+				const hex = source.length % 2 === 0 ? source : source.slice(0, source.length - 1);
+				const buffer = [];
+				for (let i = 0; i < hex.length; i += 2) buffer.push(parseInt(`${hex[i]}${hex[i + 1]}`, 16));
+				return Uint8Array.from(buffer).buffer;
+			}
+			Binary.fromHex = fromHex;
+		})(Binary || (Binary = {}));
+		Binary.fromBase64;
+		Binary.toBase64;
+		Binary.fromHex;
+		Binary.toHex;
+		/** Deep-clone common JavaScript values while preserving prototypes and cycles. */
+		function clone(source, refs = /* @__PURE__ */ new Map()) {
+			if (!source || typeof source !== "object") return source;
+			if (is("Date", source)) return new Date(source.valueOf());
+			if (is("RegExp", source)) return new RegExp(source.source, source.flags);
+			if (isArrayBufferLike(source)) return source.slice(0);
+			if (ArrayBuffer.isView(source)) return source.buffer.slice(source.byteOffset, source.byteOffset + source.byteLength);
+			const cached = refs.get(source);
+			if (cached) return cached;
+			if (Array.isArray(source)) {
+				const result = [];
+				refs.set(source, result);
+				source.forEach((value, index) => {
+					result[index] = Reflect.apply(clone, null, [value, refs]);
+				});
+				return result;
+			}
+			const result = Object.create(Object.getPrototypeOf(source));
+			refs.set(source, result);
+			for (const key of Reflect.ownKeys(source)) {
+				const descriptor = { ...Reflect.getOwnPropertyDescriptor(source, key) };
+				if ("value" in descriptor) descriptor.value = Reflect.apply(clone, null, [descriptor.value, refs]);
+				Reflect.defineProperty(result, key, descriptor);
+			}
+			return result;
+		}
+		/** Deeply compare arrays, dates, regexps, buffers, and plain object fields. */
+		function deepEqual(a, b, strict) {
+			if (a === b) return true;
+			if (!strict && isNullable(a) && isNullable(b)) return true;
+			if (typeof a !== typeof b) return false;
+			if (typeof a !== "object") return false;
+			if (!a || !b) return false;
+			function check(test, then) {
+				return test(a) ? test(b) ? then(a, b) : false : test(b) ? false : void 0;
+			}
+			return check(Array.isArray, (a, b) => a.length === b.length && a.every((item, index) => deepEqual(item, b[index]))) ?? check(is("Date"), (a, b) => a.valueOf() === b.valueOf()) ?? check(is("RegExp"), (a, b) => a.source === b.source && a.flags === b.flags) ?? check(isArrayBufferLike, (a, b) => {
+				if (a.byteLength !== b.byteLength) return false;
+				const viewA = new Uint8Array(a);
+				const viewB = new Uint8Array(b);
+				for (let i = 0; i < viewA.length; i++) if (viewA[i] !== viewB[i]) return false;
+				return true;
+			}) ?? Object.keys({
+				...a,
+				...b
+			}).every((key) => deepEqual(a[key], b[key], strict));
+		}
+		/** Time constants plus parsing and formatting helpers. */
+		var Time;
+		(function(Time) {
+			Time.millisecond = 1;
+			Time.second = 1e3;
+			Time.minute = Time.second * 60;
+			Time.hour = Time.minute * 60;
+			Time.day = Time.hour * 24;
+			Time.week = Time.day * 7;
+			let timezoneOffset = (/* @__PURE__ */ new Date()).getTimezoneOffset();
+			function setTimezoneOffset(offset) {
+				timezoneOffset = offset;
+			}
+			Time.setTimezoneOffset = setTimezoneOffset;
+			function getTimezoneOffset() {
+				return timezoneOffset;
+			}
+			Time.getTimezoneOffset = getTimezoneOffset;
+			function getDateNumber(date = /* @__PURE__ */ new Date(), offset) {
+				if (typeof date === "number") date = new Date(date);
+				if (offset === void 0) offset = timezoneOffset;
+				return Math.floor((date.valueOf() / Time.minute - offset) / 1440);
+			}
+			Time.getDateNumber = getDateNumber;
+			function fromDateNumber(value, offset) {
+				const date = new Date(value * Time.day);
+				if (offset === void 0) offset = timezoneOffset;
+				return new Date(+date + offset * Time.minute);
+			}
+			Time.fromDateNumber = fromDateNumber;
+			const numeric = /\d+(?:\.\d+)?/.source;
+			const timeRegExp = new RegExp(`^${[
+				"w(?:eek(?:s)?)?",
+				"d(?:ay(?:s)?)?",
+				"h(?:our(?:s)?)?",
+				"m(?:in(?:ute)?(?:s)?)?",
+				"s(?:ec(?:ond)?(?:s)?)?"
+			].map((unit) => `(${numeric}${unit})?`).join("")}$`);
+			function parseTime(source) {
+				const capture = timeRegExp.exec(source);
+				if (!capture) return 0;
+				return (parseFloat(capture[1]) * Time.week || 0) + (parseFloat(capture[2]) * Time.day || 0) + (parseFloat(capture[3]) * Time.hour || 0) + (parseFloat(capture[4]) * Time.minute || 0) + (parseFloat(capture[5]) * Time.second || 0);
+			}
+			Time.parseTime = parseTime;
+			function parseDate(date) {
+				const parsed = parseTime(date);
+				if (parsed) date = Date.now() + parsed;
+				else if (/^\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).toLocaleDateString()}-${date}`;
+				else if (/^\d{1,2}-\d{1,2}-\d{1,2}(:\d{1,2}){1,2}$/.test(date)) date = `${(/* @__PURE__ */ new Date()).getFullYear()}-${date}`;
+				return date ? new Date(date) : /* @__PURE__ */ new Date();
+			}
+			Time.parseDate = parseDate;
+			function format(ms) {
+				const abs = Math.abs(ms);
+				if (abs >= Time.day - Time.hour / 2) return Math.round(ms / Time.day) + "d";
+				else if (abs >= Time.hour - Time.minute / 2) return Math.round(ms / Time.hour) + "h";
+				else if (abs >= Time.minute - Time.second / 2) return Math.round(ms / Time.minute) + "m";
+				else if (abs >= Time.second) return Math.round(ms / Time.second) + "s";
+				return ms + "ms";
+			}
+			Time.format = format;
+			function toDigits(source, length = 2) {
+				return source.toString().padStart(length, "0");
+			}
+			Time.toDigits = toDigits;
+			function template(template, time = /* @__PURE__ */ new Date()) {
+				return template.replace("yyyy", time.getFullYear().toString()).replace("yy", time.getFullYear().toString().slice(2)).replace("MM", toDigits(time.getMonth() + 1)).replace("dd", toDigits(time.getDate())).replace("hh", toDigits(time.getHours())).replace("mm", toDigits(time.getMinutes())).replace("ss", toDigits(time.getSeconds())).replace("SSS", toDigits(time.getMilliseconds(), 3));
+			}
+			Time.template = template;
+		})(Time || (Time = {}));
+		//#endregion
+		//#region node_modules/.pnpm/@deepseek-ai+schemastery@3.18.1/node_modules/@deepseek-ai/schemastery/lib/index.mjs
+		const kSchema = Symbol.for("schemastery");
+		const kValidationError = Symbol.for("ValidationError");
+		globalThis.__schemastery_index__ ??= 0;
+		globalThis.__schemastery_refs__ = void 0;
+		var ValidationError = class extends TypeError {
+			options;
+			name = "ValidationError";
+			constructor(message, options) {
+				let prefix = "$";
+				for (const segment of options.path || []) if (typeof segment === "string") prefix += "." + segment;
+				else if (typeof segment === "number") prefix += "[" + segment + "]";
+				else if (typeof segment === "symbol") prefix += `[Symbol(${segment.toString()})]`;
+				if (prefix.startsWith(".")) prefix = prefix.slice(1);
+				super((prefix === "$" ? "" : `${prefix} `) + message);
+				this.options = options;
+			}
+			static is(error) {
+				return !!error?.[kValidationError];
+			}
+		};
+		Object.defineProperty(ValidationError.prototype, kValidationError, { value: true });
+		const Schema = function(options) {
+			const schema = function(data, options = {}) {
+				return Schema.resolve(data, schema, options)[0];
+			};
+			if (options.refs) {
+				const refs = mapValues(options.refs, (options) => new Schema(options));
+				const getRef = (uid) => refs[uid];
+				for (const key in refs) {
+					const options = refs[key];
+					options.sKey = getRef(options.sKey);
+					options.inner = getRef(options.inner);
+					options.list = options.list && options.list.map(getRef);
+					options.dict = options.dict && mapValues(options.dict, getRef);
+				}
+				return refs[options.uid];
+			}
+			Object.assign(schema, options);
+			if (typeof schema.callback === "string") try {
+				schema.callback = new Function("return " + schema.callback)();
+			} catch {}
+			Object.defineProperty(schema, "uid", { value: globalThis.__schemastery_index__++ });
+			Object.setPrototypeOf(schema, Schema.prototype);
+			schema.meta ||= {};
+			schema.toString = schema.toString.bind(schema);
+			return schema;
+		};
+		Schema.prototype = Object.create(Function.prototype);
+		Schema.prototype[kSchema] = true;
+		Object.defineProperty(Schema.prototype, "~standard", { get() {
+			return {
+				version: 1,
+				vendor: "schemastery",
+				validate: (value) => {
+					try {
+						return { value: Schema.resolve(value, this, {})[0] };
+					} catch (error) {
+						if (ValidationError.is(error)) return { issues: [{
+							message: error.message,
+							path: error.options.path
+						}] };
+						throw error;
+					}
+				}
+			};
+		} });
+		Schema.ValidationError = ValidationError;
+		Schema.prototype.toJSON = function toJSON() {
+			if (globalThis.__schemastery_refs__) {
+				globalThis.__schemastery_refs__[this.uid] ??= JSON.parse(JSON.stringify({ ...this }));
+				return this.uid;
+			}
+			globalThis.__schemastery_refs__ = { [this.uid]: { ...this } };
+			globalThis.__schemastery_refs__[this.uid] = JSON.parse(JSON.stringify({ ...this }));
+			const result = {
+				uid: this.uid,
+				refs: globalThis.__schemastery_refs__
+			};
+			globalThis.__schemastery_refs__ = void 0;
+			return result;
+		};
+		Schema.prototype.set = function set(key, value) {
+			this.dict[key] = value;
+			return this;
+		};
+		Schema.prototype.push = function push(value) {
+			this.list.push(value);
+			return this;
+		};
+		function mergeDesc(original, messages) {
+			const result = typeof original === "string" ? { "": original } : { ...original };
+			for (const locale in messages) {
+				const value = messages[locale];
+				if (value?.$description || value?.$desc) result[locale] = value.$description || value.$desc;
+				else if (typeof value === "string") result[locale] = value;
+			}
+			return result;
+		}
+		function getInner(value) {
+			return value?.$value ?? value?.$inner;
+		}
+		function extractKeys(data) {
+			return filterKeys(data ?? {}, (key) => !key.startsWith("$"));
+		}
+		Schema.prototype.i18n = function i18n(messages) {
+			const schema = Schema(this);
+			const desc = mergeDesc(schema.meta.description, messages);
+			if (Object.keys(desc).length) schema.meta.description = desc;
+			if (schema.dict) schema.dict = mapValues(schema.dict, (inner, key) => {
+				return inner.i18n(mapValues(messages, (data) => getInner(data)?.[key] ?? data?.[key]));
+			});
+			if (schema.list) schema.list = schema.list.map((inner, index) => {
+				return inner.i18n(mapValues(messages, (data = {}) => {
+					if (Array.isArray(getInner(data))) return getInner(data)[index];
+					if (Array.isArray(data)) return data[index];
+					return extractKeys(data);
+				}));
+			});
+			if (schema.inner) schema.inner = schema.inner.i18n(mapValues(messages, (data) => {
+				if (getInner(data)) return getInner(data);
+				return extractKeys(data);
+			}));
+			if (schema.sKey) schema.sKey = schema.sKey.i18n(mapValues(messages, (data) => data?.$key));
+			return schema;
+		};
+		Schema.prototype.extra = function extra(key, value) {
+			const schema = Schema(this);
+			schema.meta = {
+				...schema.meta,
+				[key]: value
+			};
+			return schema;
+		};
+		for (const key of [
+			"required",
+			"disabled",
+			"collapse",
+			"hidden",
+			"loose"
+		]) Object.assign(Schema.prototype, { [key](value = true) {
+			const schema = Schema(this);
+			schema.meta = {
+				...schema.meta,
+				[key]: value
+			};
+			return schema;
+		} });
+		Schema.prototype.deprecated = function deprecated() {
+			const schema = Schema(this);
+			schema.meta.badges ||= [];
+			schema.meta.badges.push({
+				text: "deprecated",
+				type: "danger"
+			});
+			return schema;
+		};
+		Schema.prototype.experimental = function experimental() {
+			const schema = Schema(this);
+			schema.meta.badges ||= [];
+			schema.meta.badges.push({
+				text: "experimental",
+				type: "warning"
+			});
+			return schema;
+		};
+		Schema.prototype.pattern = function pattern(regexp) {
+			const schema = Schema(this);
+			const pattern = pick(regexp, ["source", "flags"]);
+			schema.meta = {
+				...schema.meta,
+				pattern
+			};
+			return schema;
+		};
+		Schema.prototype.simplify = function simplify(value) {
+			if (deepEqual(value, this.meta.default, this.type === "dict")) return null;
+			if (isNullable(value)) return value;
+			if (this.type === "object" || this.type === "dict") {
+				const result = {};
+				for (const key in value) {
+					const item = (this.type === "object" ? this.dict[key] : this.inner)?.simplify(value[key]);
+					if (this.type === "dict" || !isNullable(item)) result[key] = item;
+				}
+				if (deepEqual(result, this.meta.default, this.type === "dict")) return null;
+				return result;
+			} else if (this.type === "array" || this.type === "tuple") {
+				const result = [];
+				value.forEach((value, index) => {
+					const schema = this.type === "array" ? this.inner : this.list[index];
+					const item = schema ? schema.simplify(value) : value;
+					result.push(item);
+				});
+				return result;
+			} else if (this.type === "intersect") {
+				const result = {};
+				for (const item of this.list) Object.assign(result, item.simplify(value));
+				return result;
+			} else if (this.type === "union") for (const schema of this.list) try {
+				Schema.resolve(value, schema, {});
+				return schema.simplify(value);
+			} catch {}
+			return value;
+		};
+		Schema.prototype.toString = function toString(inline) {
+			return formatters[this.type]?.(this, inline) ?? `Schema<${this.type}>`;
+		};
+		Schema.prototype.role = function role(role, extra) {
+			const schema = Schema(this);
+			schema.meta = {
+				...schema.meta,
+				role,
+				extra
+			};
+			return schema;
+		};
+		for (const key of [
+			"default",
+			"link",
+			"comment",
+			"description",
+			"max",
+			"min",
+			"step"
+		]) Object.assign(Schema.prototype, { [key](value) {
+			const schema = Schema(this);
+			schema.meta = {
+				...schema.meta,
+				[key]: value
+			};
+			return schema;
+		} });
+		const resolvers = {};
+		Schema.extend = function extend(type, resolve) {
+			resolvers[type] = resolve;
+		};
+		Schema.resolve = function resolve(data, schema, options = {}, strict = false) {
+			if (!schema) return [data];
+			if (options.ignore?.(data, schema)) return [data];
+			if (isNullable(data) && schema.type !== "lazy") {
+				if (schema.meta.required) throw new ValidationError(`missing required value`, options);
+				let current = schema;
+				let fallback = schema.meta.default;
+				while (current?.type === "intersect" && isNullable(fallback)) {
+					current = current.list[0];
+					fallback = current?.meta.default;
+				}
+				if (isNullable(fallback)) return [data];
+				data = clone(fallback);
+			}
+			const callback = resolvers[schema.type];
+			if (!callback) throw new ValidationError(`unsupported type "${schema.type}"`, options);
+			try {
+				return callback(data, schema, options, strict);
+			} catch (error) {
+				if (!schema.meta.loose) throw error;
+				return [schema.meta.default];
+			}
+		};
+		Schema.from = function from(source) {
+			if (isNullable(source)) return Schema.any();
+			else if ([
+				"string",
+				"number",
+				"boolean"
+			].includes(typeof source)) return Schema.const(source).required();
+			else if (source[kSchema]) return source;
+			else if (typeof source === "function") switch (source) {
+				case String: return Schema.string().required();
+				case Number: return Schema.number().required();
+				case Boolean: return Schema.boolean().required();
+				case Function: return Schema.function().required();
+				default: return Schema.is(source).required();
+			}
+			else throw new TypeError(`cannot infer schema from ${source}`);
+		};
+		Schema.lazy = function lazy(builder) {
+			const toJSON = () => {
+				if (!schema.inner[kSchema]) {
+					schema.inner = schema.builder();
+					schema.inner.meta = {
+						...schema.meta,
+						...schema.inner.meta
+					};
+				}
+				return schema.inner.toJSON();
+			};
+			const schema = new Schema({
+				type: "lazy",
+				builder,
+				inner: { toJSON }
+			});
+			return schema;
+		};
+		Schema.natural = function natural() {
+			return Schema.number().step(1).min(0);
+		};
+		Schema.percent = function percent() {
+			return Schema.number().step(.01).min(0).max(1).role("slider");
+		};
+		Schema.date = function date() {
+			return Schema.union([Schema.is(Date), Schema.transform(Schema.string().role("datetime"), (value, options) => {
+				const date = new Date(value);
+				if (isNaN(+date)) throw new ValidationError(`invalid date "${value}"`, options);
+				return date;
+			}, true)]);
+		};
+		Schema.regExp = function regExp(flag = "") {
+			return Schema.union([Schema.is(RegExp), Schema.transform(Schema.string().role("regexp", { flag }), (value, options) => {
+				try {
+					return new RegExp(value, flag);
+				} catch (e) {
+					throw new ValidationError(e.message, options);
+				}
+			}, true)]);
+		};
+		Schema.arrayBuffer = function arrayBuffer(encoding) {
+			return Schema.union([
+				Schema.is(ArrayBuffer),
+				Schema.is(SharedArrayBuffer),
+				Schema.transform(Schema.any(), (value, options) => {
+					if (Binary.isSource(value)) return Binary.fromSource(value);
+					throw new ValidationError(`expected ArrayBufferSource but got ${value}`, options);
+				}, true),
+				...encoding ? [Schema.transform(Schema.string(), (value, options) => {
+					try {
+						return encoding === "base64" ? Binary.fromBase64(value) : Binary.fromHex(value);
+					} catch (e) {
+						throw new ValidationError(e.message, options);
+					}
+				}, true)] : []
+			]);
+		};
+		Schema.extend("lazy", (data, schema, options, strict) => {
+			if (!schema.inner[kSchema]) {
+				schema.inner = schema.builder();
+				schema.inner.meta = {
+					...schema.meta,
+					...schema.inner.meta
+				};
+			}
+			return Schema.resolve(data, schema.inner, options, strict);
+		});
+		Schema.extend("any", (data) => {
+			return [data];
+		});
+		Schema.extend("never", (data, _, options) => {
+			throw new ValidationError(`expected nullable but got ${data}`, options);
+		});
+		Schema.extend("const", (data, { value }, options) => {
+			if (deepEqual(data, value)) return [value];
+			throw new ValidationError(`expected ${value} but got ${data}`, options);
+		});
+		function checkWithinRange(data, meta, description, options, skipMin = false) {
+			const { max = Infinity, min = -Infinity } = meta;
+			if (data > max) throw new ValidationError(`expected ${description} <= ${max} but got ${data}`, options);
+			if (data < min && !skipMin) throw new ValidationError(`expected ${description} >= ${min} but got ${data}`, options);
+		}
+		Schema.extend("string", (data, { meta }, options) => {
+			if (typeof data !== "string") throw new ValidationError(`expected string but got ${data}`, options);
+			if (meta.pattern) {
+				const regexp = new RegExp(meta.pattern.source, meta.pattern.flags);
+				if (!regexp.test(data)) throw new ValidationError(`expect string to match regexp ${regexp}`, options);
+			}
+			checkWithinRange(data.length, meta, "string length", options);
+			return [data];
+		});
+		function decimalShift(data, digits) {
+			const str = data.toString();
+			if (str.includes("e")) return data * Math.pow(10, digits);
+			const index = str.indexOf(".");
+			if (index === -1) return data * Math.pow(10, digits);
+			const frac = str.slice(index + 1);
+			const integer = str.slice(0, index);
+			if (frac.length <= digits) return +(integer + frac.padEnd(digits, "0"));
+			return +(integer + frac.slice(0, digits) + "." + frac.slice(digits));
+		}
+		function isMultipleOf(data, min, step) {
+			step = Math.abs(step);
+			if (!/^\d+\.\d+$/.test(step.toString())) return (data - min) % step === 0;
+			const index = step.toString().indexOf(".");
+			const digits = step.toString().slice(index + 1).length;
+			return Math.abs(decimalShift(data, digits) - decimalShift(min, digits)) % decimalShift(step, digits) === 0;
+		}
+		Schema.extend("number", (data, { meta }, options) => {
+			if (typeof data !== "number") throw new ValidationError(`expected number but got ${data}`, options);
+			checkWithinRange(data, meta, "number", options);
+			const { step } = meta;
+			if (step && !isMultipleOf(data, meta.min ?? 0, step)) throw new ValidationError(`expected number multiple of ${step} but got ${data}`, options);
+			return [data];
+		});
+		Schema.extend("boolean", (data, _, options) => {
+			if (typeof data === "boolean") return [data];
+			throw new ValidationError(`expected boolean but got ${data}`, options);
+		});
+		Schema.extend("bitset", (data, { bits, meta }, options) => {
+			let value = 0, keys = [];
+			if (typeof data === "number") {
+				value = data;
+				for (const key in bits) if (data & bits[key]) keys.push(key);
+			} else if (Array.isArray(data)) {
+				keys = data;
+				for (const key of keys) {
+					if (typeof key !== "string") throw new ValidationError(`expected string but got ${key}`, options);
+					if (key in bits) value |= bits[key];
+				}
+			} else throw new ValidationError(`expected number or array but got ${data}`, options);
+			if (value === meta.default) return [value];
+			return [value, keys];
+		});
+		Schema.extend("function", (data, _, options) => {
+			if (typeof data === "function") return [data];
+			throw new ValidationError(`expected function but got ${data}`, options);
+		});
+		Schema.extend("is", (data, { constructor }, options) => {
+			if (typeof constructor === "function") {
+				if (data instanceof constructor) return [data];
+				throw new ValidationError(`expected ${constructor.name} but got ${data}`, options);
+			} else {
+				if (isNullable(data)) throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+				let prototype = Object.getPrototypeOf(data);
+				while (prototype) {
+					if (prototype.constructor?.name === constructor) return [data];
+					prototype = Object.getPrototypeOf(prototype);
+				}
+				throw new ValidationError(`expected ${constructor} but got ${data}`, options);
+			}
+		});
+		function property(data, key, schema, options) {
+			try {
+				const [value, adapted] = Schema.resolve(data[key], schema, {
+					...options,
+					path: [...options.path || [], key]
+				});
+				if (adapted !== void 0) data[key] = adapted;
+				return value;
+			} catch (e) {
+				if (!options?.autofix) throw e;
+				delete data[key];
+				return schema.meta.default;
+			}
+		}
+		Schema.extend("array", (data, { inner, meta }, options) => {
+			if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+			checkWithinRange(data.length, meta, "array length", options, !isNullable(inner.meta.default));
+			return [data.map((_, index) => property(data, index, inner, options))];
+		});
+		Schema.extend("dict", (data, { inner, sKey }, options, strict) => {
+			if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+			const result = {};
+			for (const key in data) {
+				let rKey;
+				try {
+					rKey = Schema.resolve(key, sKey, options)[0];
+				} catch (error) {
+					if (strict) continue;
+					throw error;
+				}
+				result[rKey] = property(data, key, inner, options);
+				data[rKey] = data[key];
+				if (key !== rKey) delete data[key];
+			}
+			return [result];
+		});
+		Schema.extend("tuple", (data, { list }, options, strict) => {
+			if (!Array.isArray(data)) throw new ValidationError(`expected array but got ${data}`, options);
+			const result = list.map((inner, index) => property(data, index, inner, options));
+			if (strict) return [result];
+			result.push(...data.slice(list.length));
+			return [result];
+		});
+		function merge(result, data) {
+			for (const key in data) {
+				if (key in result) continue;
+				result[key] = data[key];
+			}
+		}
+		Schema.extend("object", (data, { dict }, options, strict) => {
+			if (!isPlainObject(data)) throw new ValidationError(`expected object but got ${data}`, options);
+			const result = {};
+			for (const key in dict) {
+				const value = property(data, key, dict[key], options);
+				if (!isNullable(value) || key in data) result[key] = value;
+			}
+			if (!strict) merge(result, data);
+			return [result];
+		});
+		Schema.extend("union", (data, { list, toString }, options, strict) => {
+			const messages = [];
+			for (const inner of list) try {
+				return Schema.resolve(data, inner, options, strict);
+			} catch (error) {
+				messages.push(error);
+			}
+			throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+		});
+		Schema.extend("intersect", (data, { list, toString }, options, strict) => {
+			if (!list.length) return [data];
+			let result;
+			for (const inner of list) {
+				const value = Schema.resolve(data, inner, options, true)[0];
+				if (isNullable(value)) continue;
+				if (isNullable(result)) result = value;
+				else if (typeof result !== typeof value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+				else if (typeof value === "object") merge(result ??= {}, value);
+				else if (result !== value) throw new ValidationError(`expected ${toString()} but got ${JSON.stringify(data)}`, options);
+			}
+			if (!strict && isPlainObject(data)) merge(result, data);
+			return [result];
+		});
+		Schema.extend("transform", (data, { inner, callback, preserve }, options) => {
+			const [result, adapted = data] = Schema.resolve(data, inner, options, true);
+			if (preserve) return [callback(result)];
+			else return [callback(result), callback(adapted)];
+		});
+		const formatters = {};
+		function defineMethod(name, keys, format) {
+			formatters[name] = format;
+			Object.assign(Schema, { [name](...args) {
+				const schema = new Schema({ type: name });
+				keys.forEach((key, index) => {
+					switch (key) {
+						case "sKey":
+							schema.sKey = args[index] ?? Schema.string();
+							break;
+						case "inner":
+							schema.inner = Schema.from(args[index]);
+							break;
+						case "list":
+							schema.list = args[index].map(Schema.from);
+							break;
+						case "dict":
+							schema.dict = mapValues(args[index], Schema.from);
+							break;
+						case "bits":
+							schema.bits = {};
+							for (const key in args[index]) {
+								if (typeof args[index][key] !== "number") continue;
+								schema.bits[key] = args[index][key];
+							}
+							break;
+						case "callback": {
+							const callback = schema.callback = args[index];
+							callback["toJSON"] ||= () => callback.toString();
+							break;
+						}
+						case "constructor": {
+							const constructor = schema.constructor = args[index];
+							if (typeof constructor === "function") constructor["toJSON"] ||= () => constructor["name"];
+							break;
+						}
+						default: schema[key] = args[index];
+					}
+				});
+				if (name === "object" || name === "dict") schema.meta.default = {};
+				else if (name === "array" || name === "tuple") schema.meta.default = [];
+				else if (name === "bitset") schema.meta.default = 0;
+				return schema;
+			} });
+		}
+		defineMethod("is", ["constructor"], ({ constructor }) => {
+			if (typeof constructor === "function") return constructor.name;
+			else return constructor;
+		});
+		defineMethod("any", [], () => "any");
+		defineMethod("never", [], () => "never");
+		defineMethod("const", ["value"], ({ value }) => typeof value === "string" ? JSON.stringify(value) : value);
+		defineMethod("string", [], () => "string");
+		defineMethod("number", [], () => "number");
+		defineMethod("boolean", [], () => "boolean");
+		defineMethod("bitset", ["bits"], () => "bitset");
+		defineMethod("function", [], () => "function");
+		defineMethod("array", ["inner"], ({ inner }) => `${inner.toString(true)}[]`);
+		defineMethod("dict", ["inner", "sKey"], ({ inner, sKey }) => `{ [key: ${sKey.toString()}]: ${inner.toString()} }`);
+		defineMethod("tuple", ["list"], ({ list }) => `[${list.map((inner) => inner.toString()).join(", ")}]`);
+		defineMethod("object", ["dict"], ({ dict }) => {
+			if (Object.keys(dict).length === 0) return "{}";
+			return `{ ${Object.entries(dict).map(([key, inner]) => {
+				return `${key}${inner.meta.required ? "" : "?"}: ${inner.toString()}`;
+			}).join(", ")} }`;
+		});
+		defineMethod("union", ["list"], ({ list }, inline) => {
+			const result = list.map(({ toString: format }) => format()).join(" | ");
+			return inline ? `(${result})` : result;
+		});
+		defineMethod("intersect", ["list"], ({ list }) => {
+			return `${list.map((inner) => inner.toString(true)).join(" & ")}`;
+		});
+		defineMethod("transform", [
+			"inner",
+			"callback",
+			"preserve"
+		], ({ inner }, isInner) => inner.toString(isInner));
+		//#endregion
+		//#region src/config.ts
+		/**
+		* dsh-messager 配置模型。
+		*
+		* 本 schema 同时承担两个角色：
+		* - host 端的 Loader config（cordis.yml 中该插件行的 `config:`，成为 settings 命名空间的 base 层）；
+		* - `ctx.settings.register('messager', Config, { base })` 的命名空间 schema，
+		*   因此 Web 设置页会自动渲染配置表单，用户层可覆盖 base。
+		*
+		* 有效值优先级：schema 默认值 → base（cordis.yml）→ 用户层（设置页）。
+		*/
+		const verbosity = Schema.union([
+			"minimal",
+			"normal",
+			"detailed"
+		]);
+		const Config = Schema.object({
+			triggers: Schema.object({
+				interaction: Schema.boolean().default(true),
+				completed: Schema.boolean().default(true),
+				error: Schema.boolean().default(true)
+			}),
+			system: Schema.object({
+				enabled: Schema.boolean().default(true),
+				icon: Schema.string(),
+				verbosity: verbosity.default("normal")
+			}),
+			browser: Schema.object({
+				enabled: Schema.boolean().default(true),
+				icon: Schema.string(),
+				onlyWhenHidden: Schema.boolean().default(true),
+				verbosity: verbosity.default("normal")
+			}),
+			feishu: Schema.object({
+				enabled: Schema.boolean().default(false),
+				webhookUrl: Schema.string(),
+				secret: Schema.string().role("secret"),
+				timeoutMs: Schema.number().default(5e3),
+				verbosity: verbosity.default("normal")
+			}),
+			dedup: Schema.object({
+				interactionCooldownMs: Schema.number().default(1e4),
+				completedDebounceMs: Schema.number().default(1e3),
+				perChannelPerMinute: Schema.number().default(20)
+			}),
+			message: Schema.object({
+				titlePrefix: Schema.string(),
+				includeSessionTitle: Schema.boolean().default(true),
+				guiUrl: Schema.string().default("http://127.0.0.1:3080")
+			})
+		});
+		/**
+		* 用 schema 默认值解析一份配置（输入可省略任意字段）。
+		* 与 cordis Loader 的校验同源，保证“默认值 → base → 用户层”的解析一致。
+		*/
+		function resolveConfig(input = {}) {
+			return Config(input);
+		}
+		//#endregion
+		//#region src/config-shared.ts
+		/**
+		* 配置路由的跨端共享类型（host 与浏览器 client 共用，不得 import 任何
+		* Node/浏览器专属模块）。
+		*/
+		/** 配置路由路径（挂在 DSH webServer 上，同源访问）。 */
+		const CONFIG_PATH = "/dsh-messager/config";
+		//#endregion
+		//#region src/client/config.ts
+		/**
+		* 客户端配置读取：经 host 配置路由（GET /dsh-messager/config）拉取 messager
+		* 命名空间有效值，并通过 `settings/document-updated` 失效后重拉。
+		* 路由不受 Web 设置白名单门控，发行版同样可用；拉取失败回退 schema 默认值。
+		*/
+		var ClientConfig = class {
+			current = resolveConfig({});
+			listeners = /* @__PURE__ */ new Set();
+			get() {
+				return this.current;
+			}
+			subscribe(listener) {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			}
+			/** 拉取 host 配置视图（首次与收到 document-updated 后调用）。 */
+			async refresh() {
+				try {
+					const response = await fetch(CONFIG_PATH, { headers: { accept: "application/json" } });
+					if (!response.ok) return;
+					const view = await response.json();
+					if (view.status !== "ready" || view.value === void 0) return;
+					this.current = resolveConfig(view.value);
+					for (const listener of [...this.listeners]) listener();
+				} catch {}
+			}
+		};
+		//#endregion
+		//#region src/client/diff.ts
+		/**
+		* 对比两次列表快照。
+		* 首次出现的会话只建立基线、不通知；被移除的会话不通知。
+		* @param previous - 上一次快照的 byId。
+		* @param next - 本次快照的 byId。
+		* @param current - 本次快照的当前选中会话（选中会话的完成不打扰）。
+		*/
+		function diffSessionSummaries(previous, next, current) {
+			const notices = [];
+			for (const id of Object.keys(next)) {
+				const summary = next[id];
+				if (summary === void 0) continue;
+				const before = previous[id];
+				if (before === void 0) continue;
+				if (summary.pendingInteraction !== void 0 && before.pendingInteraction === void 0) notices.push({
+					kind: "interaction",
+					sessionId: id,
+					interaction: summary.pendingInteraction,
+					title: summary.displayTitle
+				});
+				if (before.running && !summary.running && id !== current) notices.push({
+					kind: "completed",
+					sessionId: id,
+					title: summary.displayTitle
+				});
+			}
+			return notices;
+		}
+		//#endregion
+		//#region src/client/card-controller.ts
+		/** 字段键：`group.field`。 */
+		function fieldKey(group, field) {
+			return `${group}.${field}`;
+		}
+		/**
+		* 渲染层门控判断（与控制器 gatedOff 语义一致）：
+		* hiddenUnless 指定的开关字段当前（含草稿）不为 true 时，该字段不渲染。
+		*/
+		function isFieldGated(spec, fields) {
+			const gate = spec.hiddenUnless;
+			if (gate === void 0) return false;
+			return fields[fieldKey(gate.group, gate.field)]?.text !== "true";
+		}
+		/** 把草稿解析为组内值；undefined 表示非法（阻止保存）。 */
+		function parseDraft(spec, text) {
+			const trimmed = text.trim();
+			switch (spec.kind) {
+				case "toggle": return trimmed === "true" ? true : trimmed === "false" ? false : void 0;
+				case "select": return spec.options?.includes(trimmed) ? trimmed : void 0;
+				case "number": {
+					if (trimmed === "") return void 0;
+					const parsed = Number(trimmed);
+					return Number.isFinite(parsed) ? parsed : void 0;
+				}
+				case "text": return trimmed;
+			}
+		}
+		/** 把存储值格式化为草稿文本。 */
+		function formatValue(spec, value) {
+			if (spec.secret === true) return "";
+			if (value === void 0 || value === null) return "";
+			return String(value);
+		}
+		var MessagerCardController = class {
+			scope;
+			fields;
+			staged = /* @__PURE__ */ new Map();
+			listeners = /* @__PURE__ */ new Set();
+			saving = false;
+			failed = false;
+			cache = null;
+			constructor(scope, fields) {
+				this.scope = scope;
+				this.fields = fields;
+				scope.subscribe(() => this.invalidate());
+			}
+			/** 槽位注入面。 */
+			inject() {
+				return {
+					hooks: { messagerCard: {
+						getSnapshot: () => this.getSnapshot(),
+						subscribe: (listener) => {
+							this.listeners.add(listener);
+							return () => {
+								this.listeners.delete(listener);
+							};
+						}
+					} },
+					edit: (group, field, text) => this.stage(group, field, {
+						text,
+						clear: false
+					}),
+					reset: (group, field) => {
+						const spec = this.spec(group, field);
+						this.stage(group, field, {
+							text: formatValue(spec, this.baseValue(group, field)),
+							clear: true
+						});
+					},
+					save: () => {
+						this.save();
+					},
+					discard: () => {
+						if (this.staged.size === 0 && !this.failed) return;
+						this.staged.clear();
+						this.failed = false;
+						this.invalidate();
+					},
+					t: (key) => key
+				};
+			}
+			/**
+			* 读取缓存的快照。
+			* 注意：useSyncExternalStore 要求 getSnapshot 在状态未变化时返回**同一引用**，
+			* 否则 React 会以 #185（最大更新深度）崩溃 —— 因此快照按变更点惰性计算并缓存，
+			* 只有 invalidate() 之后才重建。
+			*/
+			getSnapshot() {
+				return this.cache ??= this.compute();
+			}
+			compute() {
+				const snapshot = this.scope.getSnapshot();
+				const available = snapshot.status === "ready";
+				const fields = {};
+				for (const spec of this.fields) {
+					const key = fieldKey(spec.group, spec.field);
+					const staged = this.staged.get(key);
+					const effective = this.effectiveValue(spec);
+					if (staged === void 0) {
+						fields[key] = {
+							text: formatValue(spec, effective),
+							overridden: this.userHas(spec),
+							invalid: false
+						};
+						continue;
+					}
+					fields[key] = {
+						text: staged.text,
+						overridden: staged.clear ? false : this.userHas(spec),
+						invalid: staged.clear ? false : parseDraft(spec, staged.text) === void 0
+					};
+				}
+				const plan = this.plan();
+				return {
+					available,
+					status: snapshot.status,
+					mode: snapshot.mode ?? "",
+					writable: snapshot.writable,
+					dirty: plan.length > 0,
+					invalid: plan.some((item) => item.run === void 0),
+					saving: this.saving,
+					failed: this.failed,
+					fields
+				};
+			}
+			effectiveValue(spec) {
+				const group = this.groupValue(spec.group);
+				if (group === void 0) return void 0;
+				return group[spec.field];
+			}
+			groupValue(group) {
+				const value = this.scope.getSnapshot().value;
+				if (typeof value !== "object" || value === null) return void 0;
+				const section = value[group];
+				return typeof section === "object" && section !== null ? section : void 0;
+			}
+			baseValue(group, field) {
+				const base = this.scope.getSnapshot().base;
+				if (typeof base !== "object" || base === null) return void 0;
+				const section = base[group];
+				if (typeof section !== "object" || section === null) return void 0;
+				return section[field];
+			}
+			userHas(spec) {
+				const user = this.scope.getSnapshot().user;
+				if (typeof user !== "object" || user === null) return false;
+				const section = user[spec.group];
+				return typeof section === "object" && section !== null && Object.hasOwn(section, spec.field);
+			}
+			stage(group, field, edit) {
+				this.staged.set(fieldKey(group, field), edit);
+				this.failed = false;
+				this.invalidate();
+			}
+			spec(group, field) {
+				const spec = this.fields.find((candidate) => candidate.group === group && candidate.field === field);
+				if (spec === void 0) throw new Error(`messager card has no field ${group}.${field}`);
+				return spec;
+			}
+			/**
+			* 计算保存计划：把每个有效草稿翻译为一条嵌套路径写操作。
+			* 逐字段而非整组合并：密钥字段只有被显式填写/重置时才生成 op，
+			* 其余字段互不牵连（mutate 的 set 是整组替换，合并写会抹掉未回显的密钥）。
+			*/
+			plan() {
+				const ops = [];
+				for (const [key, staged] of this.staged) {
+					const [group, field] = key.split(".");
+					const spec = this.spec(group, field);
+					if (this.gatedOff(spec)) continue;
+					if (spec.secret === true && staged.text.trim() === "" && !staged.clear) continue;
+					if (staged.clear) {
+						if (!spec.secret && !this.userHas(spec)) continue;
+						ops.push({
+							op: "unset",
+							path: [group, field]
+						});
+						continue;
+					}
+					const desired = parseDraft(spec, staged.text);
+					if (desired === void 0) return [{ run: void 0 }];
+					if (spec.secret !== true && deepEqualJson(desired, this.effectiveValue(spec))) continue;
+					ops.push({
+						op: "set",
+						path: [group, field],
+						value: desired
+					});
+				}
+				if (ops.length === 0) return [];
+				const scope = this.scope;
+				return [{ run: async () => {
+					return await scope.writeOps(ops);
+				} }];
+			}
+			/**
+			* 门控判断：hiddenUnless 指定的开关字段当前（含草稿覆盖）不为 true 时，
+			* 该字段不可见、草稿不参与保存。
+			*/
+			gatedOff(spec) {
+				const gate = spec.hiddenUnless;
+				if (gate === void 0) return false;
+				const gateKey = fieldKey(gate.group, gate.field);
+				const gateSpec = this.spec(gate.group, gate.field);
+				const staged = this.staged.get(gateKey);
+				let gateValue;
+				if (staged !== void 0 && !staged.clear) gateValue = parseDraft(gateSpec, staged.text);
+				else gateValue = this.effectiveValue(gateSpec);
+				return gateValue !== true;
+			}
+			async save() {
+				const plan = this.plan();
+				if (plan.length === 0 || this.saving || plan.some((item) => item.run === void 0)) return;
+				this.saving = true;
+				this.failed = false;
+				this.invalidate();
+				let landed = true;
+				for (const item of plan) {
+					if (item.run === void 0) continue;
+					landed = await item.run() && landed;
+				}
+				if (landed) this.staged.clear();
+				this.saving = false;
+				this.failed = !landed;
+				this.invalidate();
+			}
+			/** 失效缓存并通知订阅者（getSnapshot 下一次调用时重建）。 */
+			invalidate() {
+				this.cache = null;
+				for (const listener of [...this.listeners]) listener();
+			}
+		};
+		/** 深比较 JSON 形状数据（组对象比较）。 */
+		function deepEqualJson(a, b) {
+			if (a === b) return true;
+			if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+			if (Array.isArray(a) || Array.isArray(b)) {
+				if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+				return a.every((entry, index) => deepEqualJson(entry, b[index]));
+			}
+			const left = a;
+			const right = b;
+			const keys = Object.keys(left);
+			if (keys.length !== Object.keys(right).length) return false;
+			return keys.every((key) => key in right && deepEqualJson(left[key], right[key]));
+		}
+		/**
+		* 设置分区展示的字段清单。
+		* label/hint 为**翻译键**（见 src/client/locales.ts），渲染层经 t() 取当前语言；
+		* 键名与字典一致，缺键时 t() 原样返回键名（fail loud）。
+		*/
+		const CARD_FIELDS = [
+			{
+				group: "triggers",
+				field: "interaction",
+				kind: "toggle",
+				label: "field.triggers.interaction"
+			},
+			{
+				group: "triggers",
+				field: "completed",
+				kind: "toggle",
+				label: "field.triggers.completed"
+			},
+			{
+				group: "triggers",
+				field: "error",
+				kind: "toggle",
+				label: "field.triggers.error"
+			},
+			{
+				group: "system",
+				field: "enabled",
+				kind: "toggle",
+				label: "field.system.enabled"
+			},
+			{
+				group: "system",
+				field: "verbosity",
+				kind: "select",
+				label: "field.system.verbosity",
+				options: [
+					"minimal",
+					"normal",
+					"detailed"
+				]
+			},
+			{
+				group: "system",
+				field: "icon",
+				kind: "text",
+				label: "field.system.icon",
+				hint: "hint.system.icon"
+			},
+			{
+				group: "browser",
+				field: "enabled",
+				kind: "toggle",
+				label: "field.browser.enabled"
+			},
+			{
+				group: "browser",
+				field: "onlyWhenHidden",
+				kind: "toggle",
+				label: "field.browser.onlyWhenHidden"
+			},
+			{
+				group: "browser",
+				field: "verbosity",
+				kind: "select",
+				label: "field.browser.verbosity",
+				options: [
+					"minimal",
+					"normal",
+					"detailed"
+				]
+			},
+			{
+				group: "browser",
+				field: "icon",
+				kind: "text",
+				label: "field.browser.icon"
+			},
+			{
+				group: "feishu",
+				field: "enabled",
+				kind: "toggle",
+				label: "field.feishu.enabled"
+			},
+			{
+				group: "feishu",
+				field: "webhookUrl",
+				kind: "text",
+				label: "field.feishu.webhookUrl",
+				hiddenUnless: {
+					group: "feishu",
+					field: "enabled"
+				}
+			},
+			{
+				group: "feishu",
+				field: "secret",
+				kind: "text",
+				label: "field.feishu.secret",
+				hint: "hint.feishu.secret",
+				secret: true,
+				hiddenUnless: {
+					group: "feishu",
+					field: "enabled"
+				}
+			},
+			{
+				group: "feishu",
+				field: "timeoutMs",
+				kind: "number",
+				label: "field.feishu.timeoutMs",
+				hiddenUnless: {
+					group: "feishu",
+					field: "enabled"
+				}
+			},
+			{
+				group: "feishu",
+				field: "verbosity",
+				kind: "select",
+				label: "field.feishu.verbosity",
+				options: [
+					"minimal",
+					"normal",
+					"detailed"
+				],
+				hiddenUnless: {
+					group: "feishu",
+					field: "enabled"
+				}
+			},
+			{
+				group: "message",
+				field: "titlePrefix",
+				kind: "text",
+				label: "field.message.titlePrefix",
+				hint: "hint.message.titlePrefix"
+			},
+			{
+				group: "message",
+				field: "includeSessionTitle",
+				kind: "toggle",
+				label: "field.message.includeSessionTitle"
+			},
+			{
+				group: "message",
+				field: "guiUrl",
+				kind: "text",
+				label: "field.message.guiUrl"
+			}
+		];
+		//#endregion
+		//#region src/client/fetch-scope.ts
+		/** 创建 fetch 版 scope。 */
+		function createFetchScope(fetcher) {
+			let view = {
+				status: "loading",
+				value: void 0,
+				user: void 0,
+				base: void 0,
+				writable: false,
+				mode: "host"
+			};
+			const listeners = /* @__PURE__ */ new Set();
+			const notify = () => {
+				for (const listener of [...listeners]) listener();
+			};
+			const refresh = async () => {
+				let next;
+				try {
+					next = await fetcher.get();
+				} catch {
+					view = {
+						...view,
+						status: "unavailable"
+					};
+					notify();
+					return;
+				}
+				view = {
+					status: next.status,
+					value: next.value,
+					user: next.user,
+					base: next.base,
+					writable: next.writable,
+					mode: next.mode,
+					revision: next.revision
+				};
+				notify();
+			};
+			const scope = {
+				getSnapshot: () => view,
+				subscribe: (listener) => {
+					listeners.add(listener);
+					return () => {
+						listeners.delete(listener);
+					};
+				},
+				async set(field, value) {
+					await scope.writeOps([{
+						op: "set",
+						path: [field],
+						value
+					}]);
+				},
+				async unset(field) {
+					await scope.writeOps([{
+						op: "unset",
+						path: [field]
+					}]);
+				},
+				async writeOps(ops) {
+					const result = await fetcher.write({ ops });
+					if (result.ok) await refresh();
+					return result.ok;
+				}
+			};
+			return {
+				scope,
+				refresh
+			};
+		}
+		//#endregion
+		//#region src/client/settings-form.tsx
+		/** 分组标题的翻译键（键见 locales.ts；导出供字典一致性测试）。 */
+		const GROUP_TITLE_KEYS = {
+			triggers: "group.triggers",
+			system: "group.system",
+			browser: "group.browser",
+			feishu: "group.feishu",
+			message: "group.message"
+		};
+		const FIELD_STYLE = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 6,
+			padding: "12px 0"
+		};
+		const FIELD_HEAD_STYLE = {
+			display: "flex",
+			alignItems: "center",
+			gap: 8
+		};
+		const FIELD_LABEL_STYLE = {
+			flex: 1,
+			minWidth: 0,
+			fontSize: 13,
+			fontWeight: 500,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-primary)"
+		};
+		const BADGE_STYLE = {
+			borderRadius: 999,
+			padding: "1px 8px",
+			fontSize: 11,
+			lineHeight: "17px",
+			whiteSpace: "nowrap",
+			fontWeight: 500,
+			background: "var(--dsw-alias-bg-module-platform)",
+			color: "var(--dsw-alias-label-secondary)"
+		};
+		const RESET_STYLE = {
+			border: "none",
+			background: "none",
+			padding: 0,
+			font: "inherit",
+			fontSize: 12,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-secondary)",
+			cursor: "pointer"
+		};
+		const INPUT_STYLE = {
+			height: 34,
+			padding: "0 12px",
+			border: "1px solid var(--dsw-alias-border-l2)",
+			borderRadius: 8,
+			background: "var(--dsw-alias-bg-layer-3)",
+			font: "inherit",
+			fontSize: 13,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-primary)"
+		};
+		const HINT_STYLE = {
+			margin: 0,
+			fontSize: 12,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const INVALID_STYLE = {
+			...HINT_STYLE,
+			color: "var(--dsw-alias-label-error)"
+		};
+		const GROUP_HEADING_STYLE = {
+			margin: "12px 0 0",
+			fontSize: 12,
+			fontWeight: 600,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const READ_ONLY_STYLE = {
+			margin: "12px 0 0",
+			fontSize: 12,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const FOOTER_STYLE = {
+			display: "flex",
+			alignItems: "center",
+			justifyContent: "flex-end",
+			gap: 8,
+			padding: "12px 0 4px",
+			borderTop: "1px solid var(--dsw-alias-border-l2)",
+			marginTop: 12
+		};
+		const FAILED_STYLE = {
+			flex: 1,
+			minWidth: 0,
+			margin: 0,
+			fontSize: 12,
+			lineHeight: 1.5,
+			color: "var(--dsw-alias-label-error)"
+		};
+		const BUTTON_BASE = {
+			appearance: "none",
+			border: "1px solid transparent",
+			borderRadius: 8,
+			padding: "5px 14px",
+			font: "inherit",
+			fontSize: 13,
+			lineHeight: 1.5,
+			cursor: "pointer"
+		};
+		const DISCARD_STYLE = {
+			...BUTTON_BASE,
+			borderColor: "var(--dsw-alias-border-l2)",
+			background: "none",
+			color: "var(--dsw-alias-label-secondary)"
+		};
+		const SAVE_STYLE = {
+			...BUTTON_BASE,
+			background: "var(--dsw-alias-label-primary)",
+			color: "var(--dsw-alias-bg-layer-3)"
+		};
+		/** 渲染一个字段行（DSH ValueField 同款；toggle 标签与勾选框同一行）。 */
+		function FieldRow({ spec, state, actions, t, disabled }) {
+			const id = `dsh-messager-${spec.group}-${spec.field}`;
+			const label = t(spec.label);
+			const overriddenBadge = state.overridden && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
+				style: {
+					display: "inline-flex",
+					alignItems: "center",
+					gap: 8
+				},
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+					style: BADGE_STYLE,
+					children: t("badge.overridden")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "button",
+					style: RESET_STYLE,
+					disabled,
+					onClick: () => actions.reset(spec.group, spec.field),
+					children: t("action.reset")
+				})]
+			});
+			if (spec.kind === "toggle") return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: {
+					...FIELD_STYLE,
+					flexDirection: "row",
+					alignItems: "center",
+					flexWrap: "wrap",
+					gap: 8,
+					minHeight: 34
+				},
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+						style: {
+							...FIELD_LABEL_STYLE,
+							flex: "1 1 auto",
+							cursor: disabled ? "default" : "pointer"
+						},
+						htmlFor: id,
+						children: label
+					}),
+					overriddenBadge,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+						id,
+						type: "checkbox",
+						checked: state.text === "true",
+						disabled,
+						onChange: (event) => actions.edit(spec.group, spec.field, String(event.target.checked)),
+						style: {
+							flex: "none",
+							accentColor: "var(--dsw-alias-brand-primary)"
+						}
+					}),
+					spec.hint !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: {
+							...HINT_STYLE,
+							flexBasis: "100%"
+						},
+						children: t(spec.hint)
+					})
+				]
+			});
+			let control;
+			if (spec.kind === "select") control = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("select", {
+				id,
+				value: state.text,
+				disabled,
+				onChange: (event) => actions.edit(spec.group, spec.field, event.target.value),
+				style: {
+					...INPUT_STYLE,
+					cursor: "pointer"
+				},
+				children: spec.options?.map((option) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)("option", {
+					value: option,
+					children: option
+				}, option))
+			});
+			else control = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("input", {
+				id,
+				type: "text",
+				inputMode: spec.kind === "number" ? "numeric" : void 0,
+				value: state.text,
+				placeholder: spec.secret === true ? t("hint.feishu.secret") : void 0,
+				disabled,
+				"aria-invalid": state.invalid,
+				onChange: (event) => actions.edit(spec.group, spec.field, event.target.value),
+				style: state.invalid ? {
+					...INPUT_STYLE,
+					borderColor: "var(--dsw-alias-label-error)"
+				} : INPUT_STYLE
+			});
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: FIELD_STYLE,
+				children: [
+					/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+						style: FIELD_HEAD_STYLE,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("label", {
+							style: FIELD_LABEL_STYLE,
+							htmlFor: id,
+							children: label
+						}), overriddenBadge]
+					}),
+					control,
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+						style: state.invalid ? INVALID_STYLE : HINT_STYLE,
+						children: state.invalid ? t("status.invalidField") : spec.hint === void 0 ? "" : t(spec.hint)
+					})
+				]
+			});
+		}
+		/** key → spec 查找表（渲染时用）。 */
+		const FIELD_LOOKUP = Object.fromEntries(CARD_FIELDS.map((spec) => [`${spec.group}.${spec.field}`, spec]));
+		/**
+		* 设置表单体：全部字段分组 + 底部操作栏。
+		* @param state - 控制器快照（useMessagerCard 的返回）。
+		* @param actions - 控制器动作（edit/reset/save/discard）。
+		* @param t - 翻译函数（键 → 当前语言文案）。
+		*/
+		function MessagerSettingsForm({ state, actions, t }) {
+			const groups = [...new Set(Object.keys(state.fields).map((key) => key.split(".")[0]))];
+			const actionsDisabled = !state.writable || state.saving;
+			const blocked = !state.dirty || state.invalid || state.saving;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [
+				!state.writable && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: READ_ONLY_STYLE,
+					role: "status",
+					children: t("status.readOnly")
+				}),
+				groups.map((group) => /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: GROUP_HEADING_STYLE,
+					children: t(GROUP_TITLE_KEYS[group] ?? group)
+				}), Object.entries(state.fields).filter(([key]) => key.startsWith(`${group}.`)).map(([key, field]) => {
+					key.slice(key.indexOf(".") + 1);
+					const spec = FIELD_LOOKUP[key];
+					if (spec === void 0) return null;
+					if (isFieldGated(spec, state.fields)) return null;
+					return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(FieldRow, {
+						spec,
+						state: field,
+						actions,
+						t,
+						disabled: actionsDisabled
+					}, key);
+				})] }, group)),
+				/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+					style: FOOTER_STYLE,
+					children: [
+						state.failed && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: FAILED_STYLE,
+							role: "status",
+							children: t("status.saveFailed")
+						}),
+						state.invalid && !state.failed && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+							style: FAILED_STYLE,
+							role: "status",
+							children: t("status.invalidInput")
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							style: {
+								...DISCARD_STYLE,
+								...!state.dirty && !state.failed || state.saving ? {
+									opacity: .4,
+									cursor: "default"
+								} : {}
+							},
+							disabled: !state.dirty || state.saving,
+							onClick: actions.discard,
+							children: t("action.discard")
+						}),
+						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+							type: "button",
+							style: {
+								...SAVE_STYLE,
+								...blocked ? {
+									opacity: .4,
+									cursor: "default"
+								} : {}
+							},
+							disabled: blocked,
+							onClick: actions.save,
+							children: state.saving ? t("action.saving") : t("action.save")
+						})
+					]
+				})
+			] });
+		}
+		//#endregion
+		//#region src/client/section.tsx
+		const SECTION_STYLE = {
+			display: "flex",
+			flexDirection: "column",
+			gap: 12,
+			maxWidth: 640
+		};
+		const TITLE_STYLE = {
+			margin: 0,
+			fontSize: 18,
+			fontWeight: 600,
+			lineHeight: 1.4,
+			color: "var(--dsw-alias-label-primary)"
+		};
+		const DESCRIPTION_STYLE = {
+			margin: 0,
+			fontSize: 13,
+			lineHeight: 1.6,
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		const UNAVAILABLE_STYLE = {
+			margin: 0,
+			fontSize: 13,
+			lineHeight: 1.6,
+			color: "var(--dsw-alias-label-tertiary)"
+		};
+		/**
+		* dsh-messager 设置分区（设置页「通知&信使」）。
+		* @param props - 槽位 owner props + 注入面（useMessagerCard + 动作 + t）。
+		*/
+		function MessagerSection(props) {
+			const state = props.useMessagerCard((snapshot) => snapshot);
+			const { edit, reset, save, discard, t } = props;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+				style: SECTION_STYLE,
+				children: [/* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("h2", {
+					style: TITLE_STYLE,
+					children: t("nav")
+				}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: DESCRIPTION_STYLE,
+					children: t("section.description")
+				})] }), state.available ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(MessagerSettingsForm, {
+					state,
+					actions: {
+						edit,
+						reset,
+						save,
+						discard
+					},
+					t
+				}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
+					style: UNAVAILABLE_STYLE,
+					role: "status",
+					children: t("status.unavailable")
+				})]
+			});
+		}
+		//#endregion
+		//#region src/client/locales.ts
+		const zh = {
+			nav: "通知&信使",
+			"section.description": "会话交互 / 任务完成 / 出错时的通知推送：系统通知、浏览器通知、飞书机器人。",
+			"group.triggers": "触发时机",
+			"group.system": "系统通知",
+			"group.browser": "浏览器通知",
+			"group.feishu": "第三方推送",
+			"group.message": "消息内容",
+			"field.triggers.interaction": "需要交互时通知",
+			"field.triggers.completed": "任务完成时通知",
+			"field.triggers.error": "任务出错时通知",
+			"field.system.enabled": "启用系统通知",
+			"field.system.icon": "图标路径",
+			"field.system.verbosity": "内容繁复度",
+			"field.browser.enabled": "启用浏览器通知",
+			"field.browser.icon": "图标 URL",
+			"field.browser.onlyWhenHidden": "仅页面隐藏时通知",
+			"field.browser.verbosity": "内容繁复度",
+			"field.feishu.enabled": "飞书机器人",
+			"field.feishu.webhookUrl": "Webhook 地址",
+			"field.feishu.secret": "签名密钥",
+			"field.feishu.timeoutMs": "请求超时（毫秒）",
+			"field.feishu.verbosity": "内容繁复度",
+			"field.message.titlePrefix": "标题前缀",
+			"field.message.includeSessionTitle": "正文包含会话标题",
+			"field.message.guiUrl": "打开链接地址",
+			"hint.system.icon": "node-notifier 需要文件绝对路径",
+			"hint.feishu.secret": "留空不修改；重置可清除已存密钥",
+			"hint.message.titlePrefix": "如 [DSH]",
+			"action.save": "保存",
+			"action.saving": "保存中…",
+			"action.discard": "放弃修改",
+			"action.reset": "重置",
+			"badge.overridden": "已覆盖",
+			"status.readOnly": "设置文档当前为只读。",
+			"status.saveFailed": "保存失败，请重试。",
+			"status.invalidInput": "存在无效输入，请修正后再保存。",
+			"status.invalidField": "无效输入（数字/选项），请修正后再保存。",
+			"status.unavailable": "配置通道不可用：配置路由未就绪（host 插件未加载或 webServer 服务缺失）。"
+		};
+		const en = {
+			nav: "Messenger",
+			"section.description": "Notifications for interaction, task completion and errors: system toast, browser notification, Feishu bot.",
+			"group.triggers": "Triggers",
+			"group.system": "System",
+			"group.browser": "Browser",
+			"group.feishu": "Third-party",
+			"group.message": "Message",
+			"field.triggers.interaction": "Notify when interaction is needed",
+			"field.triggers.completed": "Notify when a task completes",
+			"field.triggers.error": "Notify when a task errors",
+			"field.system.enabled": "Enable system notifications",
+			"field.system.icon": "Icon path",
+			"field.system.verbosity": "Verbosity",
+			"field.browser.enabled": "Enable browser notifications",
+			"field.browser.icon": "Icon URL",
+			"field.browser.onlyWhenHidden": "Notify only when the page is hidden",
+			"field.browser.verbosity": "Verbosity",
+			"field.feishu.enabled": "Feishu bot",
+			"field.feishu.webhookUrl": "Webhook URL",
+			"field.feishu.secret": "Signing secret",
+			"field.feishu.timeoutMs": "Request timeout (ms)",
+			"field.feishu.verbosity": "Verbosity",
+			"field.message.titlePrefix": "Title prefix",
+			"field.message.includeSessionTitle": "Include session title in the body",
+			"field.message.guiUrl": "Open link URL",
+			"hint.system.icon": "node-notifier requires an absolute file path",
+			"hint.feishu.secret": "Leave blank to keep the stored secret; Reset clears it",
+			"hint.message.titlePrefix": "e.g. [DSH]",
+			"action.save": "Save",
+			"action.saving": "Saving…",
+			"action.discard": "Discard",
+			"action.reset": "Reset",
+			"badge.overridden": "Overridden",
+			"status.readOnly": "The settings document is read-only.",
+			"status.saveFailed": "Save failed, please retry.",
+			"status.invalidInput": "There are invalid inputs, fix them before saving.",
+			"status.invalidField": "Invalid input (number/option), fix it before saving.",
+			"status.unavailable": "Config channel unavailable: the config route is not ready (host plugin not loaded or webServer service missing)."
+		};
+		//#endregion
+		//#region src/client/index.ts
+		const name = "dsh-messager";
+		/** locale 字典命名空间（与 section 的 locale 声明一致）。 */
+		const LOCALE_NS = "dsh-messager";
+		/** 依赖的客户端服务：会话列表、远程事件（document-updated）、槽位、locale。 */
+		const inject = [
+			"sessions",
+			"remote",
+			"slots",
+			"locale"
+		];
+		/** localStorage 跨标签页去重键前缀。 */
+		const STORAGE_PREFIX = "dsh-messager:notified:";
+		/** 浏览器通知投递器。 */
+		var BrowserNotifier = class {
+			config;
+			/** `${kind}:${sessionId}` → 上次投递时间戳（内存冷却）。 */
+			cooldowns = /* @__PURE__ */ new Map();
+			constructor(config) {
+				this.config = config;
+			}
+			dispose() {
+				this.cooldowns.clear();
+			}
+			/** 列表快照变化 → 通知。 */
+			onListChange(previous, next) {
+				const config = this.config.get();
+				if (!config.browser.enabled) return;
+				if (typeof Notification === "undefined") return;
+				if (Notification.permission !== "granted") return;
+				if (config.browser.onlyWhenHidden && document.visibilityState !== "hidden") return;
+				const notices = diffSessionSummaries(previous.byId, next.byId, next.current);
+				for (const notice of notices) {
+					if (!this.allow(notice, config)) continue;
+					this.show(notice, config);
+				}
+			}
+			/** 冷却 + 跨标签页去重。 */
+			allow(notice, config) {
+				const now = Date.now();
+				const key = `${notice.kind}:${notice.sessionId}`;
+				const cooldownMs = config.dedup.interactionCooldownMs;
+				const last = this.cooldowns.get(key);
+				if (last !== void 0 && now - last < cooldownMs) return false;
+				try {
+					const storageKey = STORAGE_PREFIX + key;
+					const raw = window.localStorage.getItem(storageKey);
+					if (raw !== null && now - Number(raw) < cooldownMs) return false;
+					window.localStorage.setItem(storageKey, String(now));
+				} catch {}
+				this.cooldowns.set(key, now);
+				return true;
+			}
+			show(notice, config) {
+				const verbosity = config.browser.verbosity;
+				const notification = new Notification(this.titleOf(notice, config), {
+					...verbosity === "minimal" ? {} : { body: this.bodyOf(notice, config, verbosity) },
+					...config.browser.icon === void 0 ? {} : { icon: config.browser.icon },
+					tag: `dsh-messager:${notice.kind}:${notice.sessionId}`
+				});
+				notification.onclick = () => {
+					window.focus();
+					notification.close();
+				};
+			}
+			titleOf(notice, config) {
+				let base;
+				if (notice.kind === "interaction") base = notice.interaction === "approval" ? "需要交互：等待审批" : notice.interaction === "plan-review" ? "需要交互：计划待审" : "需要交互：等待回答";
+				else base = "任务完成";
+				const prefix = config.message.titlePrefix;
+				return prefix === void 0 || prefix === "" ? base : `${prefix} ${base}`;
+			}
+			bodyOf(notice, config, verbosity) {
+				const lines = [];
+				if (verbosity === "minimal") return "";
+				if (config.message.includeSessionTitle && notice.title !== void 0) lines.push(`会话：${notice.title}`);
+				if (verbosity === "detailed") lines.push(`打开：${config.message.guiUrl}`);
+				return lines.join("\n");
+			}
+		};
+		function apply(ctx) {
+			const config = new ClientConfig();
+			config.refresh();
+			const fetchScope = createFetchScope({
+				get: async () => {
+					const response = await fetch(CONFIG_PATH, { headers: { accept: "application/json" } });
+					if (!response.ok) throw new Error(`config route responded ${response.status}`);
+					return await response.json();
+				},
+				write: async (body) => {
+					try {
+						const response = await fetch(CONFIG_PATH, {
+							method: "POST",
+							headers: { "content-type": "application/json" },
+							body: JSON.stringify(body)
+						});
+						const result = await response.json();
+						return {
+							ok: response.ok && result.ok === true,
+							error: result.error
+						};
+					} catch (error) {
+						return {
+							ok: false,
+							error: error instanceof Error ? error.message : String(error)
+						};
+					}
+				}
+			});
+			fetchScope.refresh();
+			const offRemote = ctx.remote.$on("settings/document-updated", () => {
+				config.refresh();
+				fetchScope.refresh();
+			});
+			ctx.effect(() => () => offRemote?.(), "dsh-messager: settings invalidation");
+			const notifier = new BrowserNotifier(config);
+			ctx.effect(() => () => notifier.dispose(), "dsh-messager: browser notifier");
+			let previous = ctx.sessions.list.getSnapshot();
+			const offList = ctx.sessions.list.subscribe(() => {
+				const next = ctx.sessions.list.getSnapshot();
+				notifier.onListChange(previous, next);
+				previous = next;
+			});
+			ctx.effect(() => () => offList(), "dsh-messager: sessions subscription");
+			const controller = new MessagerCardController(fetchScope.scope, CARD_FIELDS);
+			ctx.effect(() => ctx.locale.register(LOCALE_NS, {
+				zh,
+				en
+			}), "dsh-messager: locale dictionaries");
+			const t = ctx.locale.bind(LOCALE_NS);
+			ctx.slots.inject("settings.section", function* () {
+				const existing = ctx.slots.entries("settings.section");
+				const agentPresets = existing.find((entry) => entry.options.id === "agent-presets");
+				const maxOrder = existing.reduce((max, entry) => Math.max(max, entry.options.order ?? 0), 0);
+				const order = agentPresets !== void 0 ? (agentPresets.options.order ?? 0) + 1 : existing.length > 0 ? maxOrder + 1 : 1e3;
+				const face = controller.inject();
+				yield ctx.slots.register({
+					name: "settings.section",
+					id: "dsh-messager",
+					order,
+					label: () => t("nav"),
+					locale: LOCALE_NS,
+					inject: () => ({
+						...face,
+						t
+					})
+				}, MessagerSection);
+			});
+			if (typeof Notification !== "undefined" && Notification.permission === "default") Notification.requestPermission();
+			ctx.logger.info("[dsh-messager] client loaded");
+		}
+		//#endregion
+		exports.LOCALE_NS = LOCALE_NS;
+		exports.apply = apply;
+		exports.inject = inject;
+		exports.name = name;
+		return module.exports;
+	}
+});
+
+//# sourceMappingURL=client.js.map