@fraqjs/fraq 0.13.0 → 0.13.2

package/dist/index.d.mts

@@ -5542,6 +5542,7 @@ type RouteActivation =
     }
   | {
       type: 'mention';
+      prefix?: string;
     }
   | {
       type: 'prefix';
@@ -5828,7 +5829,7 @@ declare function definePlugin<
   OI extends Injection | undefined,
 >(plugin: Plugin<T, I, OI>): Plugin<T, I, OI>;
 //#endregion
-//#region src/core/context.d.ts
+//#region src/core/context/index.d.ts
 interface ContextOptions {
   reconnect?: {
     initialDelayMs?: number;
@@ -5851,19 +5852,14 @@ declare class Context {
   private readonly parent?;
   private readonly filter?;
   private readonly eventBus;
-  private readonly plugins;
-  private readonly services;
-  private readonly apiHookEntries;
   private readonly subContexts;
-  private readonly eventSourceRuntimes;
   private readonly parentEventForwarder?;
-  private readonly timers;
-  private readonly initialReconnectDelayMs;
-  private readonly maxReconnectDelayMs;
   private readonly logHandler?;
-  private state;
-  private startPromise?;
-  private stopPromise?;
+  private readonly plugins;
+  private readonly apiHooks;
+  private readonly eventSources;
+  private readonly timers;
+  private readonly lifecycle;
   private constructor();
   on<K extends keyof EventMap>(type: K, handler: (event: EventMap[K]) => void | Promise<void>): () => void;
   install<T extends ParameterList, I extends Injection | undefined, OI extends Injection | undefined>(
@@ -5883,36 +5879,6 @@ declare class Context {
   createSession(selfId: number, message: IncomingMessage): Session;
   start(): Promise<void>;
   stop(): Promise<void>;
-  private startInternal;
-  private getState;
-  private stopInternal;
-  private assertCanRegisterApiHook;
-  private assertCanScheduleTimer;
-  private runTimerCallback;
-  private clearTimers;
-  private stopEventSources;
-  private acceptsParentEvent;
-  private applyPlugins;
-  private recursiveApplyPlugins;
-  private startPlugins;
-  private recursiveStartPlugins;
-  private sortPlugins;
-  private collectPendingProvidedServices;
-  private areRequiredServicesAvailable;
-  private areOptionalServicesReady;
-  private collectAvailableServices;
-  private createUnresolvablePluginError;
-  private getPluginContext;
-  private createProxyContextForPlugin;
-  private startEventSource;
-  private runEventSource;
-  private waitForReconnectDelay;
-  private resolveReconnectDelay;
-  private createHookClient;
-  private wrapAnyApiHook;
-  private callHookedApi;
-  private collectApiHooks;
-  private callBaseApi;
   static fromUrl(baseUrl: string | URL, options?: ContextOptions & ContextUrlOptions): Context;
   static fromClient(client: MilkyClient, options?: ContextOptions): Context;
 }

package/dist/index.mjs

@@ -314,12 +314,16 @@ var Router = class Router {
 	}
 	match(session, message) {
 		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 routeActivationInputs(activations)) {
+			const literalActivationIndex = branch.type === "rawPattern" ? Object.values(branch.rawPattern.pattern).findIndex((parameter) => parameter.capturer.typeInstruction.type === "literal") : -1;
+			let activationInputs = DEFAULT_ACTIVATIONS;
+			if (branch.type === "command" || literalActivationIndex !== -1) {
+				const descriptor = this.describeBranch(branch);
+				const activations = this.activationResolver(descriptor, session) ?? DEFAULT_ACTIVATIONS;
+				activationInputs = Array.isArray(activations) ? activations : [activations];
+			}
+			for (const activation of activationInputs) {
 				const tokenizer = new Tokenizer(message.segments);
-				if (!this.consumeActivation(tokenizer, activation, session)) continue;
-				const match = this.matchBranch(branch, tokenizer, activation);
+				const match = this.matchBranch(branch, tokenizer, activation, session, literalActivationIndex);
 				if (match !== void 0) return match;
 			}
 		}
@@ -362,15 +366,18 @@ var Router = class Router {
 	consumeActivation(tokenizer, activation, session) {
 		switch (activation.type) {
 			case "direct": return true;
-			case "mention": return tokenizer.consumeMention(session.selfId);
+			case "mention":
+				if (!tokenizer.consumeMention(session.selfId)) return false;
+				return activation.prefix === void 0 || tokenizer.consumeTextPrefix(activation.prefix);
 			case "prefix": return tokenizer.consumeTextPrefix(activation.prefix);
 		}
 	}
-	matchBranch(branch, tokenizer, activation) {
+	matchBranch(branch, tokenizer, activation, session, literalActivationIndex) {
+		if (branch.type === "command" && !this.consumeActivation(tokenizer, activation, session)) return;
 		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);
+			case "rawPattern": return this.matchRawPattern(branch.rawPattern, tokenizer, branch.path, activation, session, literalActivationIndex);
 		}
 	}
 	matchPath(path, tokenizer) {
@@ -395,9 +402,15 @@ var Router = class Router {
 			activation
 		};
 	}
-	matchRawPattern(rawPattern, tokenizer, path, activation) {
-		const params = this.capturePattern(rawPattern.pattern, tokenizer);
-		if (params === void 0 || tokenizer.hasNext()) return;
+	matchRawPattern(rawPattern, tokenizer, path, activation, session, literalActivationIndex) {
+		const params = {};
+		for (const [index, [name, parameter]] of Object.entries(rawPattern.pattern).entries()) {
+			if (index === literalActivationIndex && !this.consumeActivation(tokenizer, activation, session)) return;
+			const value = parameter.capturer.capture(tokenizer);
+			if (value === void 0) return;
+			params[name] = value;
+		}
+		if (tokenizer.hasNext()) return;
 		return {
 			type: "rawPattern",
 			path: [...path],
@@ -465,7 +478,6 @@ var Router = class Router {
 	validatePattern(pattern, options) {
 		const entries = Object.entries(pattern);
 		if (options?.rawPattern && entries.length === 0) throw new Error("Raw pattern must have at least one parameter.");
-		if (options?.rawPattern && entries[0]?.[1].capturer.typeInstruction.type === "literal") throw new Error("The first parameter of a raw pattern cannot be a literal, as it would conflict with command patterns.");
 		const catchAllEntryIndex = entries.findIndex(([, parameter]) => {
 			return parameter.capturer.typeInstruction.type === "catchAll";
 		});
@@ -485,12 +497,6 @@ var Router = class Router {
 		return params;
 	}
 };
-function routeActivationInputs(activations) {
-	return isRouteActivationArray(activations) ? activations : [activations];
-}
-function isRouteActivationArray(activations) {
-	return Array.isArray(activations);
-}
 //#endregion
 //#region src/core/activation.ts
 function createContextRouteActivationResolver(routing, fallback = defaultRouteActivationResolver) {
@@ -502,7 +508,8 @@ function createContextRouteActivationResolver(routing, fallback = defaultRouteAc
 }
 function compileContextRouteActivationConfig(config, fallback) {
 	return (route, session) => {
-		for (const rule of contextRouteActivationRules(config.rules)) {
+		const rules = config.rules === void 0 ? [] : Array.isArray(config.rules) ? config.rules : [config.rules];
+		for (const rule of rules) {
 			if (!matchesContextRouteActivationRule(route, session, rule)) continue;
 			const activation = resolveContextRouteActivation(rule.activation, session.raw.message_scene);
 			if (activation !== void 0) return activation;
@@ -514,22 +521,10 @@ function compileContextRouteActivationConfig(config, fallback) {
 		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 (isRouteActivationInput(activation)) return activation;
-	return activation[scene] ?? activation.default;
-}
-function isRouteActivationInput(activation) {
-	return Array.isArray(activation) || isRouteActivation(activation);
-}
-function isRouteActivation(activation) {
-	return "type" in activation;
+	if (Array.isArray(activation) || "type" in activation) return activation;
+	const activationByScene = activation;
+	return activationByScene[scene] ?? activationByScene.default;
 }
 function matchesContextRouteActivationRule(route, session, rule) {
 	const match = rule.match;
@@ -808,97 +803,29 @@ function combineLogHandlers(...handlers) {
 	};
 }
 //#endregion
-//#region src/core/service.ts
-function isDisposable(service) {
-	return "dispose" in service && typeof service.dispose === "function";
-}
-function implementsESNextDisposable(service) {
-	return Symbol.dispose in service && typeof service[Symbol.dispose] === "function";
-}
-//#endregion
-//#region src/core/context.ts
-const DEFAULT_INITIAL_RECONNECT_DELAY_MS = 1e3;
-const DEFAULT_MAX_RECONNECT_DELAY_MS = 3e4;
-var Context = class Context {
-	router = new Router();
-	logger;
-	name;
-	routeActivationResolver;
-	client;
+//#region src/core/context/api-hooks.ts
+var ApiHookRegistry = class {
 	baseClient;
 	parent;
-	filter;
-	eventBus = mitt();
-	plugins = [];
-	services = /* @__PURE__ */ new Map();
-	apiHookEntries = [];
-	subContexts = /* @__PURE__ */ new Map();
-	eventSourceRuntimes = /* @__PURE__ */ new Map();
-	parentEventForwarder;
-	timers = /* @__PURE__ */ new Set();
-	initialReconnectDelayMs;
-	maxReconnectDelayMs;
-	logHandler;
-	state = "idle";
-	startPromise;
-	stopPromise;
-	constructor(baseClient, options, name, parent, filter) {
+	contextName;
+	getState;
+	client;
+	entries = [];
+	constructor(baseClient, parent, contextName, getState) {
 		this.baseClient = baseClient;
-		this.client = this.createHookClient();
-		this.initialReconnectDelayMs = options?.reconnect?.initialDelayMs ?? DEFAULT_INITIAL_RECONNECT_DELAY_MS;
-		this.maxReconnectDelayMs = options?.reconnect?.maxDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
-		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) {
-			this.parentEventForwarder = (type, event) => {
-				if (!this.acceptsParentEvent(type, event)) return;
-				this.eventBus.emit(type, event);
-			};
-			parent.eventBus.on("*", this.parentEventForwarder);
-		}
-		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(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);
-			}
-		});
-	}
-	on(type, handler) {
-		const wrappedHandler = async (event) => {
-			try {
-				if (this.state === "stopping" || this.state === "stopped") return;
-				await handler(event);
-			} catch (error) {
-				this.logger.error(`Error handling event ${type}`, error);
-			}
-		};
-		this.eventBus.on(type, wrappedHandler);
-		return () => {
-			this.eventBus.off(type, wrappedHandler);
-		};
-	}
-	install(plugin, ...args) {
-		this.plugins.push({
-			plugin,
-			args
-		});
-	}
-	installEventSource(eventSource) {
-		if (this.eventSourceRuntimes.has(eventSource)) return;
-		this.eventSourceRuntimes.set(eventSource, {});
-		if (this.state === "started") this.startEventSource(eventSource);
+		this.contextName = contextName;
+		this.getState = getState;
+		this.client = this.createHookClient();
 	}
-	hookApi(endpointOrHook, hook) {
-		this.assertCanRegisterApiHook();
+	register(endpointOrHook, hook) {
+		const state = this.getState();
+		if (state === "stopping") throw new Error(`Context "${this.contextName}" cannot register API hooks while it is stopping.`);
+		if (state === "stopped") throw new Error(`Context "${this.contextName}" cannot register API hooks after it has stopped.`);
 		let entry;
-		if (typeof endpointOrHook === "function") entry = { hook: this.wrapAnyApiHook(endpointOrHook) };
+		if (typeof endpointOrHook === "function") entry = { hook: (params, next, call) => {
+			return endpointOrHook(call, (nextParams = params) => next(nextParams));
+		} };
 		else {
 			if (!hook) throw new Error(`API hook for endpoint ${endpointOrHook} is missing a handler.`);
 			entry = {
@@ -906,213 +833,98 @@ var Context = class Context {
 				hook
 			};
 		}
-		this.apiHookEntries.push(entry);
+		this.entries.push(entry);
 		let disposed = false;
 		return () => {
 			if (disposed) return;
 			disposed = true;
-			const index = this.apiHookEntries.indexOf(entry);
-			if (index !== -1) this.apiHookEntries.splice(index, 1);
+			const index = this.entries.indexOf(entry);
+			if (index !== -1) this.entries.splice(index, 1);
 		};
 	}
-	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(`
-Service ${service.name} implements ESNext Disposable but not Fraq Disposable.
-Please explicitly import the interface like this:
-
-import type { Disposable } from '@fraqjs/fraq';
-
-and implement the dispose method to clean up resources when the context stops.
-    `.trim());
-		this.services.set(service, instance);
-	}
-	resolve(service) {
-		const instance = this.tryResolve(service);
-		if (instance === void 0) throw new Error(`Service ${service.name} has not been provided.`);
-		return instance;
+	clear() {
+		this.entries.length = 0;
 	}
-	tryResolve(service) {
-		if (this.services.has(service)) return this.services.get(service);
-		return this.parent?.tryResolve(service);
+	createHookClient() {
+		return new Proxy(this.baseClient, { get: (target, prop, receiver) => {
+			if (typeof prop === "string" && prop.includes("_")) return (params) => this.callHookedApi(prop, params);
+			return Reflect.get(target, prop, receiver);
+		} });
 	}
-	isProvided(service) {
-		return this.tryResolve(service) !== void 0;
+	async callHookedApi(endpoint, params) {
+		const hooks = this.collectApiHooks(endpoint);
+		const dispatch = async (index, currentParams) => {
+			const hook = hooks[index];
+			if (!hook) return await this.callBaseApi(endpoint, currentParams);
+			let nextCalled = false;
+			return await hook(currentParams, async (nextParams = currentParams) => {
+				if (nextCalled) throw new Error(`API hook for endpoint ${endpoint} called next() multiple times.`);
+				nextCalled = true;
+				return await dispatch(index + 1, nextParams);
+			}, {
+				endpoint,
+				params: currentParams
+			});
+		};
+		return await dispatch(0, params);
 	}
-	fork(name, filter) {
-		if (this.subContexts.has(name)) {
-			if (filter) throw new Error(`Sub context "${name}" already exists, so the provided filter cannot be applied. Please use fork('${name}') without a filter to get the existing subcontext.`);
-			return this.subContexts.get(name);
+	collectApiHooks(endpoint) {
+		const hooks = [];
+		let registry = this;
+		while (registry) {
+			for (const entry of registry.entries.toReversed()) if (entry.endpoint === void 0 || entry.endpoint === endpoint) hooks.push(entry.hook);
+			registry = registry.parent;
 		}
-		const subContext = new Context(this.baseClient, void 0, name, this, filter);
-		this.subContexts.set(name, subContext);
-		return subContext;
+		return hooks;
 	}
-	timeout(delayMs, callback) {
-		this.assertCanScheduleTimer();
-		const timeout = setTimeout(() => {
-			this.timers.delete(timeout);
-			this.runTimerCallback(callback);
-		}, delayMs);
-		this.timers.add(timeout);
-		return timeout;
+	async callBaseApi(endpoint, params) {
+		const callApi = this.baseClient.callApi;
+		if (typeof callApi === "function") return await callApi.call(this.baseClient, endpoint, params);
+		const method = this.baseClient[endpoint];
+		if (typeof method !== "function") throw new Error(`Milky client does not implement API endpoint ${endpoint}.`);
+		return await method.call(this.baseClient, params);
 	}
-	interval(intervalMs, callback) {
-		this.assertCanScheduleTimer();
-		const interval = setInterval(() => {
-			this.runTimerCallback(callback);
-		}, intervalMs);
-		this.timers.add(interval);
-		return interval;
+};
+//#endregion
+//#region src/core/context/event-sources.ts
+const DEFAULT_INITIAL_RECONNECT_DELAY_MS = 1e3;
+const DEFAULT_MAX_RECONNECT_DELAY_MS = 3e4;
+var EventSourceRegistry = class {
+	logger;
+	getState;
+	emit;
+	runtimes = /* @__PURE__ */ new Map();
+	initialReconnectDelayMs;
+	maxReconnectDelayMs;
+	constructor(options, logger, getState, emit) {
+		this.logger = logger;
+		this.getState = getState;
+		this.emit = emit;
+		this.initialReconnectDelayMs = options?.initialDelayMs ?? DEFAULT_INITIAL_RECONNECT_DELAY_MS;
+		this.maxReconnectDelayMs = options?.maxDelayMs ?? DEFAULT_MAX_RECONNECT_DELAY_MS;
 	}
-	createSession(selfId, message) {
-		return {
-			selfId,
-			raw: message,
-			reply: async (textOrSegments, options) => {
-				const actualSegments = [];
-				if (typeof textOrSegments === "string") actualSegments.push({
-					type: "text",
-					data: { text: textOrSegments }
-				});
-				else actualSegments.push(...textOrSegments);
-				if (options?.withMention && message.message_scene === "group") actualSegments.unshift(seg.mention(message.sender_id));
-				if (options?.withQuote) actualSegments.unshift(seg.reply(message.message_seq));
-				switch (message.message_scene) {
-					case "friend": {
-						const { message_seq } = await this.client.send_private_message({
-							user_id: message.peer_id,
-							message: actualSegments
-						});
-						return { messageSeq: message_seq };
-					}
-					case "group": {
-						const { message_seq } = await this.client.send_group_message({
-							group_id: message.peer_id,
-							message: actualSegments
-						});
-						return { messageSeq: message_seq };
-					}
-				}
-				return { messageSeq: 0 };
-			},
-			reaction: async (type, reactionId) => {
-				if (message.message_scene === "group") await this.client.send_group_message_reaction({
-					group_id: message.peer_id,
-					message_seq: message.message_seq,
-					reaction_type: type,
-					reaction: reactionId
-				});
-			}
-		};
+	install(eventSource) {
+		if (this.runtimes.has(eventSource)) return;
+		this.runtimes.set(eventSource, {});
+		if (this.getState() === "started") this.startEventSource(eventSource);
 	}
-	async start() {
-		if (this.state === "started") return;
-		if (this.state === "starting") {
-			await this.startPromise;
-			return;
-		}
-		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot be started while it is stopping.`);
-		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot be restarted after it has been stopped.`);
-		this.state = "starting";
-		this.startPromise = this.startInternal();
-		try {
-			await this.startPromise;
-		} finally {
-			this.startPromise = void 0;
-		}
+	startAll() {
+		for (const eventSource of this.runtimes.keys()) this.startEventSource(eventSource);
 	}
 	async stop() {
-		if (this.state === "idle" && this.timers.size === 0 || this.state === "stopped") return;
-		if (this.state === "starting") await this.startPromise;
-		const stateAfterStart = this.getState();
-		if (stateAfterStart === "idle" && this.timers.size === 0 || stateAfterStart === "stopped") return;
-		if (stateAfterStart === "stopping") {
-			await this.stopPromise;
-			return;
-		}
-		this.state = "stopping";
-		this.stopPromise = this.stopInternal();
-		try {
-			await this.stopPromise;
-		} finally {
-			this.state = "stopped";
-			this.stopPromise = void 0;
-		}
-	}
-	async startInternal() {
-		const appliedContextPlugins = [];
-		const startingContexts = [];
-		try {
-			await this.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
-			await this.recursiveStartPlugins(appliedContextPlugins);
-		} catch (error) {
-			for (const context of startingContexts) if (context.state === "starting") context.state = "idle";
-			throw error;
-		}
-		for (const { context } of appliedContextPlugins) {
-			context.state = "started";
-			for (const eventSource of context.eventSourceRuntimes.keys()) context.startEventSource(eventSource);
-		}
-	}
-	getState() {
-		return this.state;
-	}
-	async stopInternal() {
 		const errors = [];
-		this.clearTimers();
-		for (const subContext of [...this.subContexts.values()].reverse()) try {
-			await subContext.stop();
-		} catch (error) {
-			errors.push(error);
-		}
-		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;
+		for (const runtime of this.runtimes.values()) {
+			this.resolveReconnectDelay(runtime);
+			const subscription = runtime.subscription;
+			if (!subscription) continue;
 			try {
-				await service.dispose();
+				await subscription.stop();
 			} catch (error) {
 				errors.push(error);
 			}
+			runtime.subscription = void 0;
 		}
-		this.apiHookEntries.length = 0;
-		if (errors.length === 1) throw errors[0];
-		if (errors.length > 1) throw new AggregateError(errors, `Context "${this.name}" failed to stop cleanly.`);
-	}
-	assertCanRegisterApiHook() {
-		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot register API hooks while it is stopping.`);
-		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot register API hooks after it has stopped.`);
-	}
-	assertCanScheduleTimer() {
-		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot schedule timers while it is stopping.`);
-		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot schedule timers after it has stopped.`);
-	}
-	async runTimerCallback(callback) {
-		if (this.state === "stopping" || this.state === "stopped") return;
-		try {
-			await callback();
-		} catch (error) {
-			this.logger.error("Error handling timer callback", error);
-		}
-	}
-	clearTimers() {
-		for (const timer of this.timers) clearTimeout(timer);
-		this.timers.clear();
-	}
-	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;
-		}
-		for (const runtime of this.eventSourceRuntimes.values()) {
+		for (const runtime of this.runtimes.values()) {
 			if (!runtime.task) continue;
 			try {
 				await runtime.task;
@@ -1122,13 +934,259 @@ and implement the dispose method to clean up resources when the context stops.
 				runtime.task = void 0;
 			}
 		}
+		return errors;
+	}
+	startEventSource(eventSource) {
+		const runtime = this.runtimes.get(eventSource);
+		if (!runtime) return;
+		runtime.task = this.runEventSource(eventSource, runtime);
+	}
+	async runEventSource(eventSource, runtime) {
+		let reconnectDelay = this.initialReconnectDelayMs;
+		let reconnectAttempt = 1;
+		while (this.getState() === "started") {
+			try {
+				this.logger.debug(`Connecting ${eventSource.name ?? "event source"} (attempt=${reconnectAttempt})`);
+				const subscription = await eventSource.start((event) => {
+					try {
+						if (this.getState() !== "started") return;
+						this.emit(event);
+					} catch (error) {
+						this.logger.error("Error handling event stream event", error);
+					}
+				});
+				if (this.getState() !== "started") {
+					await subscription.stop();
+					break;
+				}
+				runtime.subscription = subscription;
+				this.logger.info(`${eventSource.name ?? "Event source"} connected`);
+				reconnectDelay = this.initialReconnectDelayMs;
+				reconnectAttempt = 1;
+				await subscription.closed;
+				if (runtime.subscription === subscription) runtime.subscription = void 0;
+				if (this.getState() !== "started") break;
+				this.logger.warn(`${eventSource.name ?? "Event source"} disconnected; reconnecting in ${reconnectDelay}ms`);
+			} catch (error) {
+				if (this.getState() !== "started") break;
+				this.logger.error(`Error connecting ${eventSource.name ?? "event source"}; reconnecting in ${reconnectDelay}ms`, error);
+			}
+			await this.waitForReconnectDelay(runtime, reconnectDelay);
+			reconnectDelay = Math.min(reconnectDelay * 2, this.maxReconnectDelayMs);
+			reconnectAttempt += 1;
+		}
+	}
+	waitForReconnectDelay(runtime, delay) {
+		return new Promise((resolve) => {
+			runtime.resolveReconnectTimer = resolve;
+			runtime.reconnectTimer = setTimeout(() => {
+				runtime.reconnectTimer = void 0;
+				runtime.resolveReconnectTimer = void 0;
+				resolve();
+			}, delay);
+		});
+	}
+	resolveReconnectDelay(runtime) {
+		if (runtime.reconnectTimer) {
+			clearTimeout(runtime.reconnectTimer);
+			runtime.reconnectTimer = void 0;
+		}
+		const resolve = runtime.resolveReconnectTimer;
+		runtime.resolveReconnectTimer = void 0;
+		resolve?.();
+	}
+};
+//#endregion
+//#region src/core/context/lifecycle.ts
+var LifecycleManager = class {
+	contextName;
+	plugins;
+	timers;
+	eventSources;
+	apiHooks;
+	detachParentEvents;
+	children = /* @__PURE__ */ new Set();
+	currentState = "idle";
+	startPromise;
+	stopPromise;
+	constructor(contextName, plugins, timers, eventSources, apiHooks, detachParentEvents) {
+		this.contextName = contextName;
+		this.plugins = plugins;
+		this.timers = timers;
+		this.eventSources = eventSources;
+		this.apiHooks = apiHooks;
+		this.detachParentEvents = detachParentEvents;
+	}
+	get state() {
+		return this.currentState;
+	}
+	addChild(child) {
+		this.children.add(child);
+	}
+	async start() {
+		if (this.currentState === "started") return;
+		if (this.currentState === "starting") {
+			await this.startPromise;
+			return;
+		}
+		if (this.currentState === "stopping") throw new Error(`Context "${this.contextName}" cannot be started while it is stopping.`);
+		if (this.currentState === "stopped") throw new Error(`Context "${this.contextName}" cannot be restarted after it has been stopped.`);
+		this.currentState = "starting";
+		this.startPromise = this.startInternal();
+		try {
+			await this.startPromise;
+		} finally {
+			this.startPromise = void 0;
+		}
+	}
+	async stop() {
+		if (this.currentState === "idle" && !this.timers.hasTimers || this.currentState === "stopped") return;
+		let stateAfterStart = this.currentState;
+		if (stateAfterStart === "starting") {
+			await this.startPromise;
+			stateAfterStart = this.currentState;
+		}
+		if (stateAfterStart === "idle" && !this.timers.hasTimers || stateAfterStart === "stopped") return;
+		if (stateAfterStart === "stopping") {
+			await this.stopPromise;
+			return;
+		}
+		this.currentState = "stopping";
+		this.stopPromise = this.stopInternal();
+		try {
+			await this.stopPromise;
+		} finally {
+			this.currentState = "stopped";
+			this.stopPromise = void 0;
+		}
+	}
+	async startInternal() {
+		const appliedContextPlugins = [];
+		const startingContexts = [];
+		try {
+			await this.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
+			for (const { lifecycle, sortedPlugins } of appliedContextPlugins) await lifecycle.plugins.start(sortedPlugins);
+		} catch (error) {
+			for (const lifecycle of startingContexts) if (lifecycle.currentState === "starting") lifecycle.currentState = "idle";
+			throw error;
+		}
+		for (const { lifecycle } of appliedContextPlugins) {
+			lifecycle.currentState = "started";
+			lifecycle.eventSources.startAll();
+		}
+	}
+	async stopInternal() {
+		const errors = [];
+		this.timers.clear();
+		for (const child of [...this.children].reverse()) try {
+			await child.stop();
+		} catch (error) {
+			errors.push(error);
+		}
+		errors.push(...await this.eventSources.stop());
+		this.detachParentEvents();
+		errors.push(...await this.plugins.disposeServices());
+		this.apiHooks.clear();
+		if (errors.length === 1) throw errors[0];
+		if (errors.length > 1) throw new AggregateError(errors, `Context "${this.contextName}" failed to stop cleanly.`);
+	}
+	async recursiveApplyPlugins(appliedContextPlugins, startingContexts) {
+		if (this.currentState === "started") return;
+		if (this.currentState === "starting" && this.startPromise) {
+			await this.startPromise;
+			return;
+		}
+		if (this.currentState === "stopping") throw new Error(`Context "${this.contextName}" cannot be started while it is stopping.`);
+		if (this.currentState === "stopped") throw new Error(`Context "${this.contextName}" cannot be restarted after it has been stopped.`);
+		if (this.currentState === "idle") this.currentState = "starting";
+		startingContexts.push(this);
+		const sortedPlugins = await this.plugins.apply();
+		appliedContextPlugins.push({
+			lifecycle: this,
+			sortedPlugins
+		});
+		for (const child of this.children) await child.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
+	}
+};
+//#endregion
+//#region src/core/service.ts
+function isDisposable(service) {
+	return "dispose" in service && typeof service.dispose === "function";
+}
+function implementsESNextDisposable(service) {
+	return Symbol.dispose in service && typeof service[Symbol.dispose] === "function";
+}
+//#endregion
+//#region src/core/context/plugins.ts
+function areRequiredServicesAvailable(plugin, available) {
+	return (plugin.requires ?? []).every((service) => available.has(service));
+}
+function areOptionalServicesReady(plugin, available, pendingProviders) {
+	return (plugin.optionalRequires ?? []).every((service) => {
+		if (available.has(service)) return true;
+		const pendingProvider = pendingProviders.get(service);
+		return pendingProvider === void 0 || pendingProvider.plugin === plugin;
+	});
+}
+function createUnresolvablePluginError(pending, available) {
+	const missingRequirements = /* @__PURE__ */ new Map();
+	const pendingProviders = /* @__PURE__ */ new Set();
+	for (const { plugin } of pending) for (const service of plugin.provides ?? []) pendingProviders.add(service);
+	for (const { plugin } of pending) for (const service of plugin.requires ?? []) if (!available.has(service)) {
+		const plugins = missingRequirements.get(service) ?? [];
+		plugins.push(plugin);
+		missingRequirements.set(service, plugins);
+	}
+	const lines = [...missingRequirements].map(([service, plugins]) => {
+		const dependents = plugins.map((plugin) => plugin.name).join(", ");
+		const reason = pendingProviders.has(service) ? "blocked by a dependency cycle" : "no installed plugin provides it";
+		return `${service.name} required by ${dependents} (${reason})`;
+	});
+	return /* @__PURE__ */ new Error(`Unable to resolve plugin service dependencies: ${lines.join("; ")}.`);
+}
+var PluginRegistry = class {
+	context;
+	parent;
+	logHandler;
+	plugins = [];
+	services = /* @__PURE__ */ new Map();
+	constructor(context, parent, logHandler) {
+		this.context = context;
+		this.parent = parent;
+		this.logHandler = logHandler;
+	}
+	install(plugin, ...args) {
+		this.plugins.push({
+			plugin,
+			args
+		});
+	}
+	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(`
+Service ${service.name} implements ESNext Disposable but not Fraq Disposable.
+Please explicitly import the interface like this:
+
+import type { Disposable } from '@fraqjs/fraq';
+
+and implement the dispose method to clean up resources when the context stops.
+    `.trim());
+		this.services.set(service, instance);
 	}
-	acceptsParentEvent(type, event) {
-		if (!this.filter) return true;
-		const predicate = this.filter[type];
-		return predicate?.(event) === true;
+	resolve(service) {
+		const instance = this.tryResolve(service);
+		if (instance === void 0) throw new Error(`Service ${service.name} has not been provided.`);
+		return instance;
 	}
-	async applyPlugins(sortedPlugins) {
+	tryResolve(service) {
+		if (this.services.has(service)) return this.services.get(service);
+		return this.parent?.tryResolve(service);
+	}
+	isProvided(service) {
+		return this.tryResolve(service) !== void 0;
+	}
+	async apply() {
+		const sortedPlugins = this.sortPlugins();
 		for (const installedPlugin of sortedPlugins) {
 			const { plugin, args } = installedPlugin;
 			const providedBeforeApply = new Set(this.services.keys());
@@ -1140,39 +1198,31 @@ and implement the dispose method to clean up resources when the context stops.
 			if (plugin.provides) for (const service of plugin.provides) providedServices.push(service.name);
 			if (requiredServices.length > 0) applyingMessage += `, requires: [${requiredServices.join(", ")}]`;
 			if (providedServices.length > 0) applyingMessage += `, provides: [${providedServices.join(", ")}]`;
-			this.logger.info(applyingMessage);
+			this.context.logger.info(applyingMessage);
 			await plugin.apply(this.getPluginContext(installedPlugin), ...args);
 			for (const service of plugin.provides ?? []) if (!this.services.has(service) || providedBeforeApply.has(service)) throw new Error(`${plugin.name} declares service ${service.name} but did not provide it.`);
 		}
+		return sortedPlugins;
 	}
-	async recursiveApplyPlugins(appliedContextPlugins, startingContexts) {
-		if (this.state === "started") return;
-		if (this.state === "starting" && this.startPromise) {
-			await this.startPromise;
-			return;
-		}
-		if (this.state === "stopping") throw new Error(`Context "${this.name}" cannot be started while it is stopping.`);
-		if (this.state === "stopped") throw new Error(`Context "${this.name}" cannot be restarted after it has been stopped.`);
-		if (this.state === "idle") this.state = "starting";
-		startingContexts.push(this);
-		const sortedPlugins = this.sortPlugins();
-		await this.applyPlugins(sortedPlugins);
-		appliedContextPlugins.push({
-			context: this,
-			sortedPlugins
-		});
-		for (const subContext of this.subContexts.values()) await subContext.recursiveApplyPlugins(appliedContextPlugins, startingContexts);
-	}
-	async startPlugins(sortedPlugins) {
+	async start(sortedPlugins) {
 		for (const installedPlugin of sortedPlugins) {
 			const { plugin } = installedPlugin;
 			if (!plugin.start) continue;
-			this.logger.debug(`Plugin ${plugin.name} is starting...`);
+			this.context.logger.debug(`Plugin ${plugin.name} is starting...`);
 			await plugin.start(this.getPluginContext(installedPlugin));
 		}
 	}
-	async recursiveStartPlugins(appliedContextPlugins) {
-		for (const { context, sortedPlugins } of appliedContextPlugins) await context.startPlugins(sortedPlugins);
+	async disposeServices() {
+		const errors = [];
+		for (const service of [...this.services.values()].reverse()) {
+			if (!isDisposable(service)) continue;
+			try {
+				await service.dispose();
+			} catch (error) {
+				errors.push(error);
+			}
+		}
+		return errors;
 	}
 	sortPlugins() {
 		const providers = /* @__PURE__ */ new Map();
@@ -1183,64 +1233,33 @@ and implement the dispose method to clean up resources when the context stops.
 		}
 		const pending = [...this.plugins];
 		const sorted = [];
-		const available = /* @__PURE__ */ new Set();
-		for (const service of this.collectAvailableServices()) available.add(service);
+		const available = new Set(this.collectAvailableServices());
 		while (pending.length > 0) {
-			const availableByPendingPlugins = this.collectPendingProvidedServices(pending);
-			const requiredReadyIndex = pending.findIndex(({ plugin }) => this.areRequiredServicesAvailable(plugin, available));
-			const optionalReadyIndex = pending.findIndex(({ plugin }) => this.areRequiredServicesAvailable(plugin, available) && this.areOptionalServicesReady(plugin, available, availableByPendingPlugins));
+			const availableByPendingPlugins = /* @__PURE__ */ new Map();
+			for (const installedPlugin of pending) for (const service of installedPlugin.plugin.provides ?? []) availableByPendingPlugins.set(service, installedPlugin);
+			const requiredReadyIndex = pending.findIndex(({ plugin }) => areRequiredServicesAvailable(plugin, available));
+			const optionalReadyIndex = pending.findIndex(({ plugin }) => areRequiredServicesAvailable(plugin, available) && areOptionalServicesReady(plugin, available, availableByPendingPlugins));
 			const nextIndex = optionalReadyIndex === -1 ? requiredReadyIndex : optionalReadyIndex;
-			if (nextIndex === -1) throw this.createUnresolvablePluginError(pending, available);
+			if (nextIndex === -1) throw createUnresolvablePluginError(pending, available);
 			const [next] = pending.splice(nextIndex, 1);
 			sorted.push(next);
 			for (const service of next.plugin.provides ?? []) available.add(service);
 		}
 		return sorted;
 	}
-	collectPendingProvidedServices(pending) {
-		const providedServices = /* @__PURE__ */ new Map();
-		for (const installedPlugin of pending) for (const service of installedPlugin.plugin.provides ?? []) providedServices.set(service, installedPlugin);
-		return providedServices;
-	}
-	areRequiredServicesAvailable(plugin, available) {
-		return (plugin.requires ?? []).every((service) => available.has(service));
-	}
-	areOptionalServicesReady(plugin, available, pendingProviders) {
-		return (plugin.optionalRequires ?? []).every((service) => {
-			if (available.has(service)) return true;
-			const pendingProvider = pendingProviders.get(service);
-			return pendingProvider === void 0 || pendingProvider.plugin === plugin;
-		});
-	}
 	collectAvailableServices() {
 		const services = [...this.services.keys()];
 		if (this.parent) services.push(...this.parent.collectAvailableServices());
 		return services;
 	}
-	createUnresolvablePluginError(pending, available) {
-		const missingRequirements = /* @__PURE__ */ new Map();
-		const pendingProviders = /* @__PURE__ */ new Set();
-		for (const { plugin } of pending) for (const service of plugin.provides ?? []) pendingProviders.add(service);
-		for (const { plugin } of pending) for (const service of plugin.requires ?? []) if (!available.has(service)) {
-			const plugins = missingRequirements.get(service) ?? [];
-			plugins.push(plugin);
-			missingRequirements.set(service, plugins);
-		}
-		const lines = [...missingRequirements].map(([service, plugins]) => {
-			const dependents = plugins.map((plugin) => plugin.name).join(", ");
-			const reason = pendingProviders.has(service) ? "blocked by a dependency cycle" : "no installed plugin provides it";
-			return `${service.name} required by ${dependents} (${reason})`;
-		});
-		return /* @__PURE__ */ new Error(`Unable to resolve plugin service dependencies: ${lines.join("; ")}.`);
-	}
 	getPluginContext(installedPlugin) {
 		installedPlugin.proxy ??= this.createProxyContextForPlugin(installedPlugin.plugin);
 		return installedPlugin.proxy;
 	}
 	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,
+		const proxyLogger = new Logger((message) => this.logHandler?.(message), `plugin:${this.context.name ? `${this.context.name}/` : ""}${plugin.name}`);
+		const proxyRouter = this.context.router.withMeta({
+			context: this.context.name,
 			plugin: plugin.name
 		});
 		let proxyInjections;
@@ -1252,115 +1271,221 @@ and implement the dispose method to clean up resources when the context stops.
 			proxyInjections ??= {};
 			for (const [key, service] of Object.entries(plugin.optionalInject)) proxyInjections[key] = this.tryResolve(service);
 		}
-		return new Proxy(this, { get(target, prop, receiver) {
+		return new Proxy(this.context, { 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);
+			if (prop === "router") return proxyRouter;
+			if (proxyInjections && prop in proxyInjections) return proxyInjections[prop];
+			return Reflect.get(target, prop, receiver);
 		} });
 	}
-	startEventSource(eventSource) {
-		const runtime = this.eventSourceRuntimes.get(eventSource);
-		if (!runtime) return;
-		runtime.task = this.runEventSource(eventSource, runtime);
+};
+//#endregion
+//#region src/core/context/timers.ts
+var TimerRegistry = class {
+	contextName;
+	logger;
+	getState;
+	timers = /* @__PURE__ */ new Set();
+	constructor(contextName, logger, getState) {
+		this.contextName = contextName;
+		this.logger = logger;
+		this.getState = getState;
 	}
-	async runEventSource(eventSource, runtime) {
-		let reconnectDelay = this.initialReconnectDelayMs;
-		let reconnectAttempt = 1;
-		while (this.state === "started") {
-			try {
-				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);
-					} catch (error) {
-						this.logger.error("Error handling event stream event", error);
-					}
-				});
-				if (this.state !== "started") {
-					await subscription.stop();
-					break;
+	get hasTimers() {
+		return this.timers.size > 0;
+	}
+	timeout(delayMs, callback) {
+		this.assertCanScheduleTimer();
+		const timeout = setTimeout(() => {
+			this.timers.delete(timeout);
+			this.runTimerCallback(callback);
+		}, delayMs);
+		this.timers.add(timeout);
+		return timeout;
+	}
+	interval(intervalMs, callback) {
+		this.assertCanScheduleTimer();
+		const interval = setInterval(() => {
+			this.runTimerCallback(callback);
+		}, intervalMs);
+		this.timers.add(interval);
+		return interval;
+	}
+	clear() {
+		for (const timer of this.timers) clearTimeout(timer);
+		this.timers.clear();
+	}
+	assertCanScheduleTimer() {
+		const state = this.getState();
+		if (state === "stopping") throw new Error(`Context "${this.contextName}" cannot schedule timers while it is stopping.`);
+		if (state === "stopped") throw new Error(`Context "${this.contextName}" cannot schedule timers after it has stopped.`);
+	}
+	async runTimerCallback(callback) {
+		const state = this.getState();
+		if (state === "stopping" || state === "stopped") return;
+		try {
+			await callback();
+		} catch (error) {
+			this.logger.error("Error handling timer callback", error);
+		}
+	}
+};
+//#endregion
+//#region src/core/context/index.ts
+var Context = class Context {
+	router = new Router();
+	logger;
+	name;
+	routeActivationResolver;
+	client;
+	baseClient;
+	parent;
+	filter;
+	eventBus = mitt();
+	subContexts = /* @__PURE__ */ new Map();
+	parentEventForwarder;
+	logHandler;
+	plugins;
+	apiHooks;
+	eventSources;
+	timers;
+	lifecycle;
+	constructor(baseClient, options, name, parent, filter) {
+		this.baseClient = baseClient;
+		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) {
+			this.parentEventForwarder = (type, event) => {
+				if (this.filter) {
+					const predicate = this.filter[type];
+					if (predicate?.(event) !== true) return;
 				}
-				runtime.subscription = subscription;
-				this.logger.info(`${eventSource.name ?? "Event source"} connected`);
-				reconnectDelay = this.initialReconnectDelayMs;
-				reconnectAttempt = 1;
-				await subscription.closed;
-				if (runtime.subscription === subscription) runtime.subscription = void 0;
-				if (this.state !== "started") break;
-				this.logger.warn(`${eventSource.name ?? "Event source"} disconnected; reconnecting in ${reconnectDelay}ms`);
+				this.eventBus.emit(type, event);
+			};
+			parent.eventBus.on("*", this.parentEventForwarder);
+		}
+		const getState = () => this.lifecycle.state;
+		this.plugins = new PluginRegistry(this, parent?.plugins, this.logHandler);
+		this.apiHooks = new ApiHookRegistry(baseClient, parent?.apiHooks, this.name, getState);
+		this.client = this.apiHooks.client;
+		this.timers = new TimerRegistry(this.name, this.logger, getState);
+		this.eventSources = new EventSourceRegistry(options?.reconnect, this.logger, getState, (event) => {
+			this.eventBus.emit(event.event_type, event);
+		});
+		this.lifecycle = new LifecycleManager(this.name, this.plugins, this.timers, this.eventSources, this.apiHooks, () => {
+			if (this.parent && this.parentEventForwarder) this.parent.eventBus.off("*", this.parentEventForwarder);
+		});
+		parent?.lifecycle.addChild(this.lifecycle);
+		this.eventBus.on("message_receive", async ({ self_id, data: message }) => {
+			try {
+				if (this.lifecycle.state === "stopping" || this.lifecycle.state === "stopped") return;
+				await this.router.dispatch(this.createSession(self_id, message), message);
 			} catch (error) {
-				if (this.state !== "started") break;
-				this.logger.error(`Error connecting ${eventSource.name ?? "event source"}; reconnecting in ${reconnectDelay}ms`, error);
+				this.logger.error(`Error routing command (scene=${message.message_scene} peer=${message.peer_id} sender=${message.sender_id} seq=${message.message_seq})`, error);
 			}
-			await this.waitForReconnectDelay(runtime, reconnectDelay);
-			reconnectDelay = Math.min(reconnectDelay * 2, this.maxReconnectDelayMs);
-			reconnectAttempt += 1;
-		}
-	}
-	waitForReconnectDelay(runtime, delay) {
-		return new Promise((resolve) => {
-			runtime.resolveReconnectTimer = resolve;
-			runtime.reconnectTimer = setTimeout(() => {
-				runtime.reconnectTimer = void 0;
-				runtime.resolveReconnectTimer = void 0;
-				resolve();
-			}, delay);
 		});
 	}
-	resolveReconnectDelay(runtime) {
-		if (runtime.reconnectTimer) {
-			clearTimeout(runtime.reconnectTimer);
-			runtime.reconnectTimer = void 0;
+	on(type, handler) {
+		const wrappedHandler = async (event) => {
+			try {
+				if (this.lifecycle.state === "stopping" || this.lifecycle.state === "stopped") return;
+				await handler(event);
+			} catch (error) {
+				this.logger.error(`Error handling event ${type}`, error);
+			}
+		};
+		this.eventBus.on(type, wrappedHandler);
+		return () => {
+			this.eventBus.off(type, wrappedHandler);
+		};
+	}
+	install(plugin, ...args) {
+		this.plugins.install(plugin, ...args);
+	}
+	installEventSource(eventSource) {
+		this.eventSources.install(eventSource);
+	}
+	hookApi(endpointOrHook, hook) {
+		return this.apiHooks.register(endpointOrHook, hook);
+	}
+	provide(service, instance) {
+		this.plugins.provide(service, instance);
+	}
+	resolve(service) {
+		return this.plugins.resolve(service);
+	}
+	tryResolve(service) {
+		return this.plugins.tryResolve(service);
+	}
+	isProvided(service) {
+		return this.plugins.isProvided(service);
+	}
+	fork(name, filter) {
+		if (this.subContexts.has(name)) {
+			if (filter) throw new Error(`Sub context "${name}" already exists, so the provided filter cannot be applied. Please use fork('${name}') without a filter to get the existing subcontext.`);
+			return this.subContexts.get(name);
 		}
-		const resolve = runtime.resolveReconnectTimer;
-		runtime.resolveReconnectTimer = void 0;
-		resolve?.();
+		const subContext = new Context(this.baseClient, void 0, name, this, filter);
+		this.subContexts.set(name, subContext);
+		return subContext;
 	}
-	createHookClient() {
-		return new Proxy(this.baseClient, { get: (target, prop, receiver) => {
-			if (typeof prop === "string" && prop.includes("_")) return (params) => this.callHookedApi(prop, params);
-			return Reflect.get(target, prop, receiver);
-		} });
+	timeout(delayMs, callback) {
+		return this.timers.timeout(delayMs, callback);
 	}
-	wrapAnyApiHook(hook) {
-		return (params, next, call) => {
-			return hook(call, (nextParams = params) => next(nextParams));
-		};
+	interval(intervalMs, callback) {
+		return this.timers.interval(intervalMs, callback);
 	}
-	async callHookedApi(endpoint, params) {
-		const hooks = this.collectApiHooks(endpoint);
-		const dispatch = async (index, currentParams) => {
-			const hook = hooks[index];
-			if (!hook) return await this.callBaseApi(endpoint, currentParams);
-			let nextCalled = false;
-			return await hook(currentParams, async (nextParams = currentParams) => {
-				if (nextCalled) throw new Error(`API hook for endpoint ${endpoint} called next() multiple times.`);
-				nextCalled = true;
-				return await dispatch(index + 1, nextParams);
-			}, {
-				endpoint,
-				params: currentParams
-			});
+	createSession(selfId, message) {
+		return {
+			selfId,
+			raw: message,
+			reply: async (textOrSegments, options) => {
+				const actualSegments = [];
+				if (typeof textOrSegments === "string") actualSegments.push({
+					type: "text",
+					data: { text: textOrSegments }
+				});
+				else actualSegments.push(...textOrSegments);
+				if (options?.withMention && message.message_scene === "group") actualSegments.unshift(seg.mention(message.sender_id));
+				if (options?.withQuote) actualSegments.unshift(seg.reply(message.message_seq));
+				switch (message.message_scene) {
+					case "friend": {
+						const { message_seq } = await this.client.send_private_message({
+							user_id: message.peer_id,
+							message: actualSegments
+						});
+						return { messageSeq: message_seq };
+					}
+					case "group": {
+						const { message_seq } = await this.client.send_group_message({
+							group_id: message.peer_id,
+							message: actualSegments
+						});
+						return { messageSeq: message_seq };
+					}
+				}
+				return { messageSeq: 0 };
+			},
+			reaction: async (type, reactionId) => {
+				if (message.message_scene === "group") await this.client.send_group_message_reaction({
+					group_id: message.peer_id,
+					message_seq: message.message_seq,
+					reaction_type: type,
+					reaction: reactionId
+				});
+			}
 		};
-		return await dispatch(0, params);
 	}
-	collectApiHooks(endpoint) {
-		const hooks = [];
-		let context = this;
-		while (context) {
-			for (const entry of context.apiHookEntries.toReversed()) if (entry.endpoint === void 0 || entry.endpoint === endpoint) hooks.push(entry.hook);
-			context = context.parent;
-		}
-		return hooks;
+	async start() {
+		await this.lifecycle.start();
 	}
-	async callBaseApi(endpoint, params) {
-		const callApi = this.baseClient.callApi;
-		if (typeof callApi === "function") return await callApi.call(this.baseClient, endpoint, params);
-		const method = this.baseClient[endpoint];
-		if (typeof method !== "function") throw new Error(`Milky client does not implement API endpoint ${endpoint}.`);
-		return await method.call(this.baseClient, params);
+	async stop() {
+		await this.lifecycle.stop();
 	}
 	static fromUrl(baseUrl, options) {
 		const client = createMilkyClient(baseUrl, { accessToken: options?.accessToken });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fraqjs/fraq",
   "type": "module",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "Milky Bot framework",
   "files": [
     "dist"