@fraqjs/fraq 0.10.3 → 0.12.0

package/dist/index.mjs

@@ -1,201 +1,4 @@
 import mitt from "mitt";
-//#region src/protocol/client.ts
-var MilkyClientBase = class {
-	baseUrl;
-	wsBaseUrl;
-	accessToken;
-	baseHeaders;
-	constructor(baseUrl, options) {
-		const normalizedBaseUrl = baseUrl.toString();
-		this.baseUrl = normalizedBaseUrl.endsWith("/") ? normalizedBaseUrl.slice(0, -1) : normalizedBaseUrl;
-		this.wsBaseUrl = this.baseUrl.replace(/^http/, "ws");
-		this.accessToken = options?.accessToken;
-		this.baseHeaders = { "Content-Type": "application/json" };
-		if (options?.accessToken) this.baseHeaders.Authorization = `Bearer ${options.accessToken}`;
-	}
-	async callApi(endpoint, params) {
-		const response = await fetch(`${this.baseUrl}/api/${endpoint}`, {
-			method: "POST",
-			body: JSON.stringify(params ?? {}),
-			headers: this.baseHeaders
-		});
-		if (!response.ok) throw new Error(`API call ${endpoint} failed with HTTP status ${response.status}`);
-		const json = await response.json();
-		if (json.status === "failed") throw new Error(`API call ${endpoint} failed with retcode ${json.retcode}: ${json.message}`);
-		return json.data;
-	}
-	async startEvents(onEvent) {
-		const ws = new WebSocket(`${this.wsBaseUrl}/event${this.accessToken ? `?access_token=${this.accessToken}` : ""}`);
-		let closeSubscription = () => {};
-		const closed = new Promise((resolve, reject) => {
-			closeSubscription = (error) => {
-				if (error) reject(error);
-				else resolve();
-			};
-		});
-		ws.addEventListener("message", async (event) => {
-			try {
-				if (typeof event.data !== "string") throw new Error(`Expected text frame, got ${typeof event.data}`);
-				await onEvent(JSON.parse(event.data));
-			} catch (error) {
-				closeSubscription(error);
-				ws.close();
-			}
-		});
-		await new Promise((resolve, reject) => {
-			ws.addEventListener("open", () => resolve(), { once: true });
-			ws.addEventListener("error", (event) => reject(/* @__PURE__ */ new Error(`WebSocket error: ${event}`)));
-		});
-		ws.addEventListener("error", (event) => closeSubscription(/* @__PURE__ */ new Error(`WebSocket error: ${event}`)));
-		ws.addEventListener("close", () => closeSubscription(), { once: true });
-		return {
-			closed,
-			stop() {
-				ws.close();
-			}
-		};
-	}
-};
-function createMilkyClient(...params) {
-	const base = new MilkyClientBase(...params);
-	return new Proxy(base, { get(target, endpoint) {
-		if (typeof endpoint === "string" && endpoint.includes("_")) return (params) => target.callApi(endpoint, params);
-		else return target[endpoint];
-	} });
-}
-//#endregion
-//#region src/protocol/segment.ts
-function msg(strings, ...values) {
-	let buffer = "";
-	const segments = [];
-	for (let i = 0; i < strings.length; i++) {
-		buffer += strings[i];
-		if (i < values.length) {
-			const value = values[i];
-			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") buffer += value.toString();
-			else {
-				if (buffer) {
-					segments.push({
-						type: "text",
-						data: { text: buffer }
-					});
-					buffer = "";
-				}
-				segments.push(value);
-			}
-		}
-	}
-	if (buffer) segments.push({
-		type: "text",
-		data: { text: buffer }
-	});
-	return trimBoundaryTextSegments(segments);
-}
-function isTextSegment(segment) {
-	return segment.type === "text";
-}
-function withText(segment, text) {
-	return {
-		...segment,
-		data: {
-			...segment.data,
-			text
-		}
-	};
-}
-function trimBoundaryTextSegments(segments) {
-	const result = [...segments];
-	const first = result[0];
-	if (first && isTextSegment(first)) {
-		const text = first.data.text.trimStart();
-		if (text) result[0] = withText(first, text);
-		else result.shift();
-	}
-	const lastIndex = result.length - 1;
-	const last = result[lastIndex];
-	if (last && isTextSegment(last)) {
-		const text = last.data.text.trimEnd();
-		if (text) result[lastIndex] = withText(last, text);
-		else result.pop();
-	}
-	return result;
-}
-let seg;
-(function(_seg) {
-	function mention(userId) {
-		return {
-			type: "mention",
-			data: { user_id: userId }
-		};
-	}
-	_seg.mention = mention;
-	function mentionAll() {
-		return {
-			type: "mention_all",
-			data: {}
-		};
-	}
-	_seg.mentionAll = mentionAll;
-	function face(faceId, options) {
-		return {
-			type: "face",
-			data: {
-				face_id: faceId.toString(),
-				is_large: options?.isLarge ?? false
-			}
-		};
-	}
-	_seg.face = face;
-	function reply(messageSeq) {
-		return {
-			type: "reply",
-			data: { message_seq: messageSeq }
-		};
-	}
-	_seg.reply = reply;
-	function image(uri, options) {
-		return {
-			type: "image",
-			data: {
-				uri,
-				sub_type: options?.subType,
-				summary: options?.summary
-			}
-		};
-	}
-	_seg.image = image;
-	function record(uri) {
-		return {
-			type: "record",
-			data: { uri }
-		};
-	}
-	_seg.record = record;
-	function video(uri, options) {
-		return {
-			type: "video",
-			data: {
-				uri,
-				thumb_uri: options?.thumbUri
-			}
-		};
-	}
-	_seg.video = video;
-	function forward(messages, options) {
-		return {
-			type: "forward",
-			data: {
-				messages,
-				title: options?.title,
-				preview: options?.preview,
-				summary: options?.summary,
-				prompt: options?.prompt
-			}
-		};
-	}
-	_seg.forward = forward;
-})(seg || (seg = {}));
-//#endregion
 //#region src/routing/command.ts
 var CommandBuilder = class {
 	name;
@@ -205,6 +8,7 @@ var CommandBuilder = class {
 	description;
 	aliases;
 	hidden;
+	routeMeta;
 	constructor(name, sink = (command) => command) {
 		this.name = name;
 		this.sink = sink;
@@ -226,6 +30,14 @@ var CommandBuilder = class {
 		this.hidden = true;
 		return this;
 	}
+	meta(meta) {
+		this.routeMeta = mergeRouteMeta(this.routeMeta, meta);
+		return this;
+	}
+	tag(...tags) {
+		this.routeMeta = mergeRouteMeta(this.routeMeta, { tags });
+		return this;
+	}
 	execute(executor) {
 		this.executor = executor;
 		const command = {
@@ -236,9 +48,31 @@ var CommandBuilder = class {
 		if (this.description !== void 0) command.description = this.description;
 		if (this.aliases !== void 0) command.aliases = this.aliases;
 		if (this.hidden !== void 0) command.hidden = this.hidden;
+		if (this.routeMeta !== void 0) command.meta = this.routeMeta;
 		return this.sink(command);
 	}
 };
+function mergeRouteMeta(left, right) {
+	if (left === void 0 && right === void 0) return;
+	const merged = {
+		...left ?? {},
+		...right ?? {}
+	};
+	const tags = uniqueTags(left?.tags, right?.tags);
+	if (tags.length > 0) merged.tags = tags;
+	else delete merged.tags;
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function uniqueTags(...tagLists) {
+	const tags = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const tagList of tagLists) for (const tag of tagList ?? []) {
+		if (seen.has(tag)) continue;
+		seen.add(tag);
+		tags.push(tag);
+	}
+	return tags;
+}
 //#endregion
 //#region src/routing/tokenizer.ts
 const WHITESPACE_CHARS = new Set([
@@ -343,6 +177,33 @@ var Tokenizer = class {
 		this.subOffset = void 0;
 		return segments;
 	}
+	consumeMention(userId) {
+		const token = this.peek();
+		if (typeof token === "object" && token !== null && token.type === "mention" && token.data.user_id === userId) {
+			this.next();
+			return true;
+		}
+		return false;
+	}
+	consumeTextPrefix(prefix) {
+		if (prefix.length === 0) return false;
+		const position = this.findNextPosition();
+		if (position === void 0) return false;
+		const segment = this.segments[position.offset];
+		if (segment.type !== "text") return false;
+		const prefixStart = this.findTextTokenStart(segment.data.text, position.subOffset ?? 0);
+		if (!segment.data.text.startsWith(prefix, prefixStart)) return false;
+		const prefixEnd = prefixStart + prefix.length;
+		const nextSubOffset = this.findTextTokenStart(segment.data.text, prefixEnd);
+		if (nextSubOffset < segment.data.text.length) {
+			this.offset = position.offset;
+			this.subOffset = nextSubOffset;
+		} else {
+			this.offset = position.offset + 1;
+			this.subOffset = void 0;
+		}
+		return true;
+	}
 	findNextPosition() {
 		let offset = this.offset;
 		let subOffset = this.subOffset;
@@ -374,19 +235,35 @@ var Tokenizer = class {
 };
 //#endregion
 //#region src/routing/router.ts
+const DEFAULT_ACTIVATIONS = [{ type: "direct" }];
+const defaultRouteActivationResolver = () => DEFAULT_ACTIVATIONS;
 var Router = class Router {
 	entries = [];
 	groups = /* @__PURE__ */ new Map();
+	activationResolver = defaultRouteActivationResolver;
+	scopeMeta;
+	setActivationResolver(resolver) {
+		this.activationResolver = resolver;
+		return this;
+	}
+	withMeta(meta) {
+		const router = new Router();
+		router.entries = this.entries;
+		router.groups = this.groups;
+		router.scopeMeta = mergeRouteMeta(this.scopeMeta, meta);
+		return router;
+	}
 	command(command) {
 		if (typeof command === "string") return new CommandBuilder(command, (builtCommand) => {
 			this.command(builtCommand);
 			return builtCommand;
 		});
-		this.validatePattern(command.pattern);
-		this.resolveAliasConflicts(command);
+		const scopedCommand = this.applyScopeMeta(command);
+		this.validatePattern(scopedCommand.pattern);
+		this.resolveAliasConflicts(scopedCommand);
 		this.entries.push({
 			type: "command",
-			command
+			command: scopedCommand
 		});
 		return this;
 	}
@@ -395,10 +272,11 @@ var Router = class Router {
 			this.rawPattern(builtCommand);
 			return builtCommand;
 		});
-		this.validatePattern(rawPattern.pattern, { rawPattern: true });
+		const scopedRawPattern = this.applyScopeMeta(rawPattern);
+		this.validatePattern(scopedRawPattern.pattern, { rawPattern: true });
 		this.entries.push({
 			type: "rawPattern",
-			rawPattern
+			rawPattern: scopedRawPattern
 		});
 		return this;
 	}
@@ -413,7 +291,7 @@ var Router = class Router {
 				router
 			});
 		}
-		return router;
+		return this.scopeMeta ? router.withMeta(this.scopeMeta) : router;
 	}
 	filter(predicate) {
 		const router = new Router();
@@ -422,7 +300,7 @@ var Router = class Router {
 			predicate,
 			router
 		});
-		return router;
+		return this.scopeMeta ? router.withMeta(this.scopeMeta) : router;
 	}
 	routes() {
 		return this.entries;
@@ -432,11 +310,19 @@ var Router = class Router {
 		return [];
 	}
 	branches(session) {
-		return this.branchesFrom(session, []);
+		return [...this.branchesFrom(session, [], { includeHidden: false })];
 	}
 	match(session, message) {
-		const tokenizer = new Tokenizer(message.segments);
-		return this.matchFrom(session, tokenizer, []);
+		for (const branch of this.branchesFrom(session, [], { includeHidden: true })) {
+			const descriptor = this.describeBranch(branch);
+			const activations = this.activationResolver(descriptor, session) ?? DEFAULT_ACTIVATIONS;
+			for (const activation of activations) {
+				const tokenizer = new Tokenizer(message.segments);
+				if (!this.consumeActivation(tokenizer, activation, session)) continue;
+				const match = this.matchBranch(branch, tokenizer, activation);
+				if (match !== void 0) return match;
+			}
+		}
 	}
 	async dispatch(session, message) {
 		const match = this.match(session, message);
@@ -451,26 +337,51 @@ var Router = class Router {
 		}
 		return true;
 	}
-	matchFrom(session, tokenizer, path) {
-		const initialState = tokenizer.getState();
-		for (const entry of this.entries) {
-			tokenizer.setState(initialState);
-			const match = this.matchEntry(entry, session, tokenizer, path);
-			if (match !== void 0) return match;
+	describeBranch(branch) {
+		switch (branch.type) {
+			case "command": {
+				const descriptor = {
+					type: "command",
+					path: [...branch.path],
+					name: branch.command.name
+				};
+				if (branch.command.aliases !== void 0) descriptor.aliases = [...branch.command.aliases];
+				if (branch.command.meta !== void 0) descriptor.meta = branch.command.meta;
+				return descriptor;
+			}
+			case "rawPattern": {
+				const descriptor = {
+					type: "rawPattern",
+					path: [...branch.path]
+				};
+				if (branch.rawPattern.meta !== void 0) descriptor.meta = branch.rawPattern.meta;
+				return descriptor;
+			}
 		}
-		tokenizer.setState(initialState);
 	}
-	matchEntry(entry, session, tokenizer, path) {
-		switch (entry.type) {
-			case "command": return this.matchCommand(entry.command, tokenizer, path);
-			case "group": return this.matchGroup(entry.name, entry.router, session, tokenizer, path);
-			case "filter":
-				if (entry.predicate(session) !== true) return;
-				return entry.router.matchFrom(session, tokenizer, path);
-			case "rawPattern": return this.matchRawPattern(entry.rawPattern, tokenizer, path);
+	consumeActivation(tokenizer, activation, session) {
+		switch (activation.type) {
+			case "direct": return true;
+			case "mention": return tokenizer.consumeMention(session.selfId);
+			case "prefix": return tokenizer.consumeTextPrefix(activation.prefix);
+		}
+	}
+	matchBranch(branch, tokenizer, activation) {
+		if (!this.matchPath(branch.path, tokenizer)) return;
+		switch (branch.type) {
+			case "command": return this.matchCommand(branch.command, tokenizer, branch.path, activation);
+			case "rawPattern": return this.matchRawPattern(branch.rawPattern, tokenizer, branch.path, activation);
+		}
+	}
+	matchPath(path, tokenizer) {
+		for (const name of path) {
+			const token = tokenizer.peek();
+			if (typeof token !== "string" || token !== name) return false;
+			tokenizer.next();
 		}
+		return true;
 	}
-	matchCommand(command, tokenizer, path) {
+	matchCommand(command, tokenizer, path, activation) {
 		const token = tokenizer.peek();
 		if (typeof token !== "string" || token !== command.name && !command.aliases?.includes(token)) return;
 		tokenizer.next();
@@ -480,50 +391,55 @@ var Router = class Router {
 			type: "command",
 			path: [...path],
 			command,
-			params
+			params,
+			activation
 		};
 	}
-	matchGroup(name, router, session, tokenizer, path) {
-		const token = tokenizer.peek();
-		if (typeof token !== "string" || token !== name) return;
-		tokenizer.next();
-		return router.matchFrom(session, tokenizer, [...path, name]);
-	}
-	matchRawPattern(rawPattern, tokenizer, path) {
+	matchRawPattern(rawPattern, tokenizer, path, activation) {
 		const params = this.capturePattern(rawPattern.pattern, tokenizer);
 		if (params === void 0 || tokenizer.hasNext()) return;
 		return {
 			type: "rawPattern",
 			path: [...path],
 			rawPattern,
-			params
+			params,
+			activation
 		};
 	}
-	branchesFrom(session, path) {
-		const branches = [];
+	*branchesFrom(session, path, options) {
 		for (const entry of this.entries) switch (entry.type) {
 			case "command":
-				if (!entry.command.hidden) branches.push({
+				if (options.includeHidden || !entry.command.hidden) yield {
 					type: "command",
 					path: [...path],
-					command: entry.command
-				});
+					command: entry.command,
+					meta: entry.command.meta
+				};
 				break;
 			case "group":
-				branches.push(...entry.router.branchesFrom(session, [...path, entry.name]));
+				yield* entry.router.branchesFrom(session, [...path, entry.name], options);
 				break;
 			case "filter":
-				if (entry.predicate(session) === true) branches.push(...entry.router.branchesFrom(session, path));
+				if (entry.predicate(session) === true) yield* entry.router.branchesFrom(session, path, options);
 				break;
 			case "rawPattern":
-				branches.push({
+				yield {
 					type: "rawPattern",
 					path: [...path],
-					rawPattern: entry.rawPattern
-				});
+					rawPattern: entry.rawPattern,
+					meta: entry.rawPattern.meta
+				};
 				break;
 		}
-		return branches;
+	}
+	applyScopeMeta(route) {
+		if (this.scopeMeta === void 0) return route;
+		const meta = mergeRouteMeta(route.meta, this.scopeMeta);
+		if (meta === void 0) return route;
+		return {
+			...route,
+			meta
+		};
 	}
 	resolveAliasConflicts(command) {
 		for (const entry of this.entries) {
@@ -570,6 +486,283 @@ var Router = class Router {
 	}
 };
 //#endregion
+//#region src/core/activation.ts
+function createContextRouteActivationResolver(routing, fallback = defaultRouteActivationResolver) {
+	if (!routing) return fallback;
+	if (routing.activation && routing.activationResolver) throw new Error("Context routing cannot specify both activation and activationResolver.");
+	if (routing.activationResolver) return routing.activationResolver;
+	if (routing.activation) return compileContextRouteActivationConfig(routing.activation, fallback);
+	return fallback;
+}
+function compileContextRouteActivationConfig(config, fallback) {
+	return (route, session) => {
+		for (const rule of contextRouteActivationRules(config.rules)) {
+			if (!matchesContextRouteActivationRule(route, session, rule)) continue;
+			const activation = resolveContextRouteActivation(rule.activation, session.raw.message_scene);
+			if (activation !== void 0) return activation;
+		}
+		if (config.default !== void 0) {
+			const activation = resolveContextRouteActivation(config.default, session.raw.message_scene);
+			if (activation !== void 0) return activation;
+		}
+		return fallback(route, session);
+	};
+}
+function contextRouteActivationRules(rules) {
+	if (rules === void 0) return [];
+	return isContextRouteActivationRuleArray(rules) ? rules : [rules];
+}
+function isContextRouteActivationRuleArray(rules) {
+	return Array.isArray(rules);
+}
+function resolveContextRouteActivation(activation, scene) {
+	if (isRouteActivationArray(activation)) return activation;
+	return activation[scene] ?? activation.default;
+}
+function isRouteActivationArray(activation) {
+	return Array.isArray(activation);
+}
+function matchesContextRouteActivationRule(route, session, rule) {
+	const match = rule.match;
+	if (!match) return true;
+	if (!matchesStringSelector(match.type, route.type)) return false;
+	if (!matchesStringSelector(match.plugin, routeMetaString(route, "plugin"))) return false;
+	if (!matchesStringSelector(match.context, routeMetaString(route, "context"))) return false;
+	if (!matchesTagSelector(match.tag, route.meta?.tags)) return false;
+	if (match.command !== void 0 && (route.type !== "command" || !matchesStringSelector(match.command, route.name))) return false;
+	if (match.path !== void 0 && !sameStringArray(match.path, route.path)) return false;
+	if (match.route !== void 0 && !sameStringArray(match.route, routeSegments(route))) return false;
+	if (match.predicate && match.predicate(route, session) !== true) return false;
+	return true;
+}
+function routeMetaString(route, key) {
+	const value = route.meta?.[key];
+	return typeof value === "string" ? value : void 0;
+}
+function matchesStringSelector(selector, value) {
+	if (selector === void 0) return true;
+	if (value === void 0) return false;
+	return typeof selector === "string" ? selector === value : selector.includes(value);
+}
+function matchesTagSelector(selector, tags) {
+	if (selector === void 0) return true;
+	if (!tags) return false;
+	return typeof selector === "string" ? tags.includes(selector) : selector.some((tag) => tags.includes(tag));
+}
+function routeSegments(route) {
+	if (route.type === "command") return [...route.path, route.name];
+	return route.path;
+}
+function sameStringArray(left, right) {
+	return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+//#endregion
+//#region src/protocol/client.ts
+var MilkyClientBase = class {
+	baseUrl;
+	wsBaseUrl;
+	accessToken;
+	baseHeaders;
+	constructor(baseUrl, options) {
+		const normalizedBaseUrl = baseUrl.toString();
+		this.baseUrl = normalizedBaseUrl.endsWith("/") ? normalizedBaseUrl.slice(0, -1) : normalizedBaseUrl;
+		this.wsBaseUrl = this.baseUrl.replace(/^http/, "ws");
+		this.accessToken = options?.accessToken;
+		this.baseHeaders = { "Content-Type": "application/json" };
+		if (options?.accessToken) this.baseHeaders.Authorization = `Bearer ${options.accessToken}`;
+	}
+	async callApi(endpoint, params) {
+		const response = await fetch(`${this.baseUrl}/api/${endpoint}`, {
+			method: "POST",
+			body: JSON.stringify(params ?? {}),
+			headers: this.baseHeaders
+		});
+		if (!response.ok) throw new Error(`API call ${endpoint} failed with HTTP status ${response.status}`);
+		const json = await response.json();
+		if (json.status === "failed") throw new Error(`API call ${endpoint} failed with retcode ${json.retcode}: ${json.message}`);
+		return json.data;
+	}
+};
+function createMilkyClient(...params) {
+	const base = new MilkyClientBase(...params);
+	return new Proxy(base, { get(target, endpoint) {
+		if (typeof endpoint === "string" && endpoint.includes("_")) return (params) => target.callApi(endpoint, params);
+		else return target[endpoint];
+	} });
+}
+//#endregion
+//#region src/protocol/event.ts
+function createMilkyWebSocketEventSource(baseUrl, options) {
+	const normalizedBaseUrl = baseUrl.toString();
+	const wsBaseUrl = normalizedBaseUrl.endsWith("/") ? normalizedBaseUrl.slice(0, -1).replace(/^http/, "ws") : normalizedBaseUrl.replace(/^http/, "ws");
+	return {
+		name: "websocket",
+		async start(onEvent) {
+			const ws = new WebSocket(`${wsBaseUrl}/event${options?.accessToken ? `?access_token=${options.accessToken}` : ""}`);
+			let closeSubscription = () => {};
+			const closed = new Promise((resolve, reject) => {
+				closeSubscription = (error) => {
+					if (error) reject(error);
+					else resolve();
+				};
+			});
+			ws.addEventListener("message", async (event) => {
+				try {
+					if (typeof event.data !== "string") throw new Error(`Expected text frame, got ${typeof event.data}`);
+					await onEvent(JSON.parse(event.data));
+				} catch (error) {
+					closeSubscription(error);
+					ws.close();
+				}
+			});
+			await new Promise((resolve, reject) => {
+				ws.addEventListener("open", () => resolve(), { once: true });
+				ws.addEventListener("error", (event) => reject(/* @__PURE__ */ new Error(`WebSocket error: ${event}`)));
+			});
+			ws.addEventListener("error", (event) => closeSubscription(/* @__PURE__ */ new Error(`WebSocket error: ${event}`)));
+			ws.addEventListener("close", () => closeSubscription(), { once: true });
+			return {
+				closed,
+				stop() {
+					ws.close();
+				}
+			};
+		}
+	};
+}
+//#endregion
+//#region src/protocol/segment.ts
+function msg(strings, ...values) {
+	let buffer = "";
+	const segments = [];
+	for (let i = 0; i < strings.length; i++) {
+		buffer += strings[i];
+		if (i < values.length) {
+			const value = values[i];
+			if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") buffer += value.toString();
+			else {
+				if (buffer) {
+					segments.push({
+						type: "text",
+						data: { text: buffer }
+					});
+					buffer = "";
+				}
+				segments.push(value);
+			}
+		}
+	}
+	if (buffer) segments.push({
+		type: "text",
+		data: { text: buffer }
+	});
+	return trimBoundaryTextSegments(segments);
+}
+function isTextSegment(segment) {
+	return segment.type === "text";
+}
+function withText(segment, text) {
+	return {
+		...segment,
+		data: {
+			...segment.data,
+			text
+		}
+	};
+}
+function trimBoundaryTextSegments(segments) {
+	const result = [...segments];
+	const first = result[0];
+	if (first && isTextSegment(first)) {
+		const text = first.data.text.trimStart();
+		if (text) result[0] = withText(first, text);
+		else result.shift();
+	}
+	const lastIndex = result.length - 1;
+	const last = result[lastIndex];
+	if (last && isTextSegment(last)) {
+		const text = last.data.text.trimEnd();
+		if (text) result[lastIndex] = withText(last, text);
+		else result.pop();
+	}
+	return result;
+}
+let seg;
+(function(_seg) {
+	function mention(userId) {
+		return {
+			type: "mention",
+			data: { user_id: userId }
+		};
+	}
+	_seg.mention = mention;
+	function mentionAll() {
+		return {
+			type: "mention_all",
+			data: {}
+		};
+	}
+	_seg.mentionAll = mentionAll;
+	function face(faceId, options) {
+		return {
+			type: "face",
+			data: {
+				face_id: faceId.toString(),
+				is_large: options?.isLarge ?? false
+			}
+		};
+	}
+	_seg.face = face;
+	function reply(messageSeq) {
+		return {
+			type: "reply",
+			data: { message_seq: messageSeq }
+		};
+	}
+	_seg.reply = reply;
+	function image(uri, options) {
+		return {
+			type: "image",
+			data: {
+				uri,
+				sub_type: options?.subType,
+				summary: options?.summary
+			}
+		};
+	}
+	_seg.image = image;
+	function record(uri) {
+		return {
+			type: "record",
+			data: { uri }
+		};
+	}
+	_seg.record = record;
+	function video(uri, options) {
+		return {
+			type: "video",
+			data: {
+				uri,
+				thumb_uri: options?.thumbUri
+			}
+		};
+	}
+	_seg.video = video;
+	function forward(messages, options) {
+		return {
+			type: "forward",
+			data: {
+				messages,
+				title: options?.title,
+				preview: options?.preview,
+				summary: options?.summary,
+				prompt: options?.prompt
+			}
+		};
+	}
+	_seg.forward = forward;
+})(seg || (seg = {}));
+//#endregion
 //#region src/core/logging.ts
 var Logger = class {
 	logHandler;
@@ -622,12 +815,14 @@ var Context = class Context {
 	router = new Router();
 	logger;
 	name;
+	routeActivationResolver;
 	parent;
 	filter;
 	eventBus = mitt();
 	plugins = [];
 	services = /* @__PURE__ */ new Map();
 	subContexts = /* @__PURE__ */ new Map();
+	eventSourceRuntimes = /* @__PURE__ */ new Map();
 	parentEventForwarder;
 	timers = /* @__PURE__ */ new Set();
 	initialReconnectDelayMs;
@@ -636,10 +831,6 @@ var Context = class Context {
 	state = "idle";
 	startPromise;
 	stopPromise;
-	eventSubscription;
-	eventStreamTask;
-	reconnectTimer;
-	resolveReconnectTimer;
 	constructor(client, options, name, parent, filter) {
 		this.client = client;
 		this.initialReconnectDelayMs = options?.reconnect?.initialDelayMs ?? DEFAULT_INITIAL_RECONNECT_DELAY_MS;
@@ -647,6 +838,8 @@ var Context = class Context {
 		this.logHandler = options?.logHandler ?? parent?.logHandler;
 		this.name = name ?? "root";
 		this.logger = new Logger((message) => this.logHandler?.(message), `context:${this.name}`);
+		this.routeActivationResolver = createContextRouteActivationResolver(options?.routing, parent?.routeActivationResolver);
+		this.router.setActivationResolver(this.routeActivationResolver);
 		this.parent = parent;
 		this.filter = filter;
 		if (parent) {
@@ -656,10 +849,10 @@ var Context = class Context {
 			};
 			parent.eventBus.on("*", this.parentEventForwarder);
 		}
-		this.eventBus.on("message_receive", async ({ data: message }) => {
+		this.eventBus.on("message_receive", async ({ self_id, data: message }) => {
 			try {
 				if (this.state === "stopping" || this.state === "stopped") return;
-				await this.router.dispatch(this.createSession(message), message);
+				await this.router.dispatch(this.createSession(self_id, message), message);
 			} catch (error) {
 				this.logger.error(`Error routing command (scene=${message.message_scene} peer=${message.peer_id} sender=${message.sender_id} seq=${message.message_seq})`, error);
 			}
@@ -685,6 +878,11 @@ var Context = class Context {
 			args
 		});
 	}
+	installEventSource(eventSource) {
+		if (this.eventSourceRuntimes.has(eventSource)) return;
+		this.eventSourceRuntimes.set(eventSource, {});
+		if (this.state === "started") this.startEventSource(eventSource);
+	}
 	provide(service, instance) {
 		if (this.services.has(service)) throw new Error(`Service ${service.name} has already been provided in this context.`);
 		if (implementsESNextDisposable(instance) && !isDisposable(instance)) throw new Error(`
@@ -735,8 +933,9 @@ and implement the dispose method to clean up resources when the context stops.
 		this.timers.add(interval);
 		return interval;
 	}
-	createSession(message) {
+	createSession(selfId, message) {
 		return {
+			selfId,
 			raw: message,
 			reply: async (textOrSegments, options) => {
 				const actualSegments = [];
@@ -819,8 +1018,10 @@ and implement the dispose method to clean up resources when the context stops.
 			for (const context of startingContexts) if (context.state === "starting") context.state = "idle";
 			throw error;
 		}
-		for (const { context } of appliedContextPlugins) context.state = "started";
-		if (!this.parent) this.eventStreamTask = this.runEventStream();
+		for (const { context } of appliedContextPlugins) {
+			context.state = "started";
+			for (const eventSource of context.eventSourceRuntimes.keys()) context.startEventSource(eventSource);
+		}
 	}
 	getState() {
 		return this.state;
@@ -833,7 +1034,7 @@ and implement the dispose method to clean up resources when the context stops.
 		} catch (error) {
 			errors.push(error);
 		}
-		await this.stopEventStream(errors);
+		await this.stopEventSources(errors);
 		if (this.parent && this.parentEventForwarder) this.parent.eventBus.off("*", this.parentEventForwarder);
 		for (const service of [...this.services.values()].reverse()) {
 			if (!isDisposable(service)) continue;
@@ -862,20 +1063,27 @@ and implement the dispose method to clean up resources when the context stops.
 		for (const timer of this.timers) clearTimeout(timer);
 		this.timers.clear();
 	}
-	async stopEventStream(errors) {
-		this.resolveReconnectDelay();
-		const subscription = this.eventSubscription;
-		if (subscription) try {
-			await subscription.stop();
-		} catch (error) {
-			errors.push(error);
+	async stopEventSources(errors) {
+		for (const [_, runtime] of this.eventSourceRuntimes) {
+			this.resolveReconnectDelay(runtime);
+			const subscription = runtime.subscription;
+			if (!subscription) continue;
+			try {
+				await subscription.stop();
+			} catch (error) {
+				errors.push(error);
+			}
+			runtime.subscription = void 0;
 		}
-		if (this.eventStreamTask) try {
-			await this.eventStreamTask;
-		} catch (error) {
-			errors.push(error);
-		} finally {
-			this.eventStreamTask = void 0;
+		for (const runtime of this.eventSourceRuntimes.values()) {
+			if (!runtime.task) continue;
+			try {
+				await runtime.task;
+			} catch (error) {
+				errors.push(error);
+			} finally {
+				runtime.task = void 0;
+			}
 		}
 	}
 	acceptsParentEvent(type, event) {
@@ -994,6 +1202,10 @@ and implement the dispose method to clean up resources when the context stops.
 	}
 	createProxyContextForPlugin(plugin) {
 		const proxyLogger = new Logger((message) => this.logHandler?.(message), `plugin:${this.name ? `${this.name}/` : ""}${plugin.name}`);
+		const proxyRouter = this.router.withMeta({
+			context: this.name,
+			plugin: plugin.name
+		});
 		let proxyInjections;
 		if (plugin.inject) {
 			proxyInjections = {};
@@ -1005,17 +1217,23 @@ and implement the dispose method to clean up resources when the context stops.
 		}
 		return new Proxy(this, { get(target, prop, receiver) {
 			if (prop === "logger") return proxyLogger;
+			else if (prop === "router") return proxyRouter;
 			else if (proxyInjections && prop in proxyInjections) return proxyInjections[prop];
 			else return Reflect.get(target, prop, receiver);
 		} });
 	}
-	async runEventStream() {
+	startEventSource(eventSource) {
+		const runtime = this.eventSourceRuntimes.get(eventSource);
+		if (!runtime) return;
+		runtime.task = this.runEventSource(eventSource, runtime);
+	}
+	async runEventSource(eventSource, runtime) {
 		let reconnectDelay = this.initialReconnectDelayMs;
 		let reconnectAttempt = 1;
 		while (this.state === "started") {
 			try {
-				this.logger.debug(`Connecting event stream (attempt=${reconnectAttempt})`);
-				const subscription = await this.client.startEvents((event) => {
+				this.logger.debug(`Connecting ${eventSource.name ?? "event source"} (attempt=${reconnectAttempt})`);
+				const subscription = await eventSource.start((event) => {
 					try {
 						if (this.state !== "started") return;
 						this.eventBus.emit(event.event_type, event);
@@ -1027,48 +1245,52 @@ and implement the dispose method to clean up resources when the context stops.
 					await subscription.stop();
 					break;
 				}
-				this.eventSubscription = subscription;
-				this.logger.info("Event stream connected");
+				runtime.subscription = subscription;
+				this.logger.info(`${eventSource.name ?? "Event source"} connected`);
 				reconnectDelay = this.initialReconnectDelayMs;
 				reconnectAttempt = 1;
 				await subscription.closed;
-				this.eventSubscription = void 0;
+				if (runtime.subscription === subscription) runtime.subscription = void 0;
 				if (this.state !== "started") break;
-				this.logger.warn(`Event stream disconnected; reconnecting in ${reconnectDelay}ms`);
+				this.logger.warn(`${eventSource.name ?? "Event source"} disconnected; reconnecting in ${reconnectDelay}ms`);
 			} catch (error) {
-				this.eventSubscription = void 0;
 				if (this.state !== "started") break;
-				this.logger.error(`Error connecting event stream; reconnecting in ${reconnectDelay}ms`, error);
+				this.logger.error(`Error connecting ${eventSource.name ?? "event source"}; reconnecting in ${reconnectDelay}ms`, error);
 			}
-			await this.waitForReconnectDelay(reconnectDelay);
+			await this.waitForReconnectDelay(runtime, reconnectDelay);
 			reconnectDelay = Math.min(reconnectDelay * 2, this.maxReconnectDelayMs);
 			reconnectAttempt += 1;
 		}
 	}
-	waitForReconnectDelay(delay) {
+	waitForReconnectDelay(runtime, delay) {
 		return new Promise((resolve) => {
-			this.resolveReconnectTimer = resolve;
-			this.reconnectTimer = setTimeout(() => {
-				this.reconnectTimer = void 0;
-				this.resolveReconnectTimer = void 0;
+			runtime.resolveReconnectTimer = resolve;
+			runtime.reconnectTimer = setTimeout(() => {
+				runtime.reconnectTimer = void 0;
+				runtime.resolveReconnectTimer = void 0;
 				resolve();
 			}, delay);
 		});
 	}
-	resolveReconnectDelay() {
-		if (this.reconnectTimer) {
-			clearTimeout(this.reconnectTimer);
-			this.reconnectTimer = void 0;
+	resolveReconnectDelay(runtime) {
+		if (runtime.reconnectTimer) {
+			clearTimeout(runtime.reconnectTimer);
+			runtime.reconnectTimer = void 0;
 		}
-		const resolve = this.resolveReconnectTimer;
-		this.resolveReconnectTimer = void 0;
+		const resolve = runtime.resolveReconnectTimer;
+		runtime.resolveReconnectTimer = void 0;
 		resolve?.();
 	}
 	static fromUrl(baseUrl, options) {
-		return new Context(createMilkyClient(baseUrl, { accessToken: options?.accessToken }), options);
+		const context = new Context(createMilkyClient(baseUrl, { accessToken: options?.accessToken }), options);
+		if (options?.installEventSource ?? true) context.installEventSource(createMilkyWebSocketEventSource(baseUrl, { accessToken: options?.accessToken }));
+		return context;
 	}
 	static fromClient(client, options) {
-		return new Context(client, options);
+		const context = new Context(client, options);
+		const eventSourceLike = client;
+		if (typeof eventSourceLike.start === "function") context.installEventSource(eventSourceLike);
+		return context;
 	}
 };
 //#endregion
@@ -1226,7 +1448,7 @@ function definePlugin(plugin) {
 //#endregion
 //#region src/protocol/types.ts
 const milkyVersion = "1.3";
-const milkyPackageVersion = "1.3.0-rc.1";
+const milkyPackageVersion = "1.3.0-rc.2";
 //#endregion
 //#region src/routing/parameter.ts
 var Parameter = class Parameter {
@@ -1352,4 +1574,4 @@ let param;
 	_param.segment = segment;
 })(param || (param = {}));
 //#endregion
-export { CommandBuilder, Context, Logger, Parameter, Router, combineLogHandlers, createMilkyClient, definePlugin, filter, implementsESNextDisposable, isDisposable, milkyPackageVersion, milkyVersion, msg, param, seg };
+export { CommandBuilder, Context, Logger, Parameter, Router, combineLogHandlers, createContextRouteActivationResolver, createMilkyClient, createMilkyWebSocketEventSource, defaultRouteActivationResolver, definePlugin, filter, implementsESNextDisposable, isDisposable, mergeRouteMeta, milkyPackageVersion, milkyVersion, msg, param, seg };