@oh-my-pi/pi-coding-agent 11.8.2 → 11.8.3

package/src/discovery/codex.ts

@@ -28,7 +28,7 @@ import type { SlashCommand } from "../capability/slash-command";
 import { slashCommandCapability } from "../capability/slash-command";
 import type { CustomTool } from "../capability/tool";
 import { toolCapability } from "../capability/tool";
-import type { LoadContext, LoadResult } from "../capability/types";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseFrontmatter } from "../utils/frontmatter";
 import {
 	createSourceMeta,
@@ -276,8 +276,7 @@ async function loadSlashCommands(ctx: LoadContext): Promise<LoadResult<SlashComm
 	const projectCommandsDir = path.join(codexDir, "commands");
 
 	const transformCommand =
-		(level: "user" | "project") =>
-		(name: string, content: string, path: string, source: ReturnType<typeof createSourceMeta>) => {
+		(level: "user" | "project") => (name: string, content: string, path: string, source: SourceMeta) => {
 			const { frontmatter, body } = parseFrontmatter(content, { source: path });
 			const commandName = frontmatter.name || name.replace(/\.md$/, "");
 			return {
@@ -315,12 +314,7 @@ async function loadPrompts(ctx: LoadContext): Promise<LoadResult<Prompt>> {
 	const codexDir = getProjectCodexDir(ctx);
 	const projectPromptsDir = path.join(codexDir, "prompts");
 
-	const transformPrompt = (
-		name: string,
-		content: string,
-		path: string,
-		source: ReturnType<typeof createSourceMeta>,
-	) => {
+	const transformPrompt = (name: string, content: string, path: string, source: SourceMeta) => {
 		const { frontmatter, body } = parseFrontmatter(content, { source: path });
 		const promptName = frontmatter.name || name.replace(/\.md$/, "");
 		return {
@@ -359,8 +353,7 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const projectHooksDir = path.join(codexDir, "hooks");
 
 	const transformHook =
-		(level: "user" | "project") =>
-		(name: string, _content: string, path: string, source: ReturnType<typeof createSourceMeta>) => {
+		(level: "user" | "project") => (name: string, _content: string, path: string, source: SourceMeta) => {
 			const baseName = name.replace(/\.(ts|js)$/, "");
 			const match = baseName.match(/^(pre|post)-(.+)$/);
 			const hookType = (match?.[1] as "pre" | "post") || "pre";
@@ -402,8 +395,7 @@ async function loadTools(ctx: LoadContext): Promise<LoadResult<CustomTool>> {
 	const projectToolsDir = path.join(codexDir, "tools");
 
 	const transformTool =
-		(level: "user" | "project") =>
-		(name: string, _content: string, path: string, source: ReturnType<typeof createSourceMeta>) => {
+		(level: "user" | "project") => (name: string, _content: string, path: string, source: SourceMeta) => {
 			const toolName = name.replace(/\.(ts|js)$/, "");
 			return {
 				name: toolName,

package/src/discovery/cursor.ts

@@ -20,7 +20,7 @@ import type { Rule } from "../capability/rule";
 import { ruleCapability } from "../capability/rule";
 import type { Settings } from "../capability/settings";
 import { settingsCapability } from "../capability/settings";
-import type { LoadContext, LoadResult } from "../capability/types";
+import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
 import { parseFrontmatter } from "../utils/frontmatter";
 import {
 	createSourceMeta,
@@ -136,12 +136,7 @@ async function loadRules(ctx: LoadContext): Promise<LoadResult<Rule>> {
 	return { items, warnings };
 }
 
-function transformMDCRule(
-	name: string,
-	content: string,
-	path: string,
-	source: ReturnType<typeof createSourceMeta>,
-): Rule {
+function transformMDCRule(name: string, content: string, path: string, source: SourceMeta): Rule {
 	const { frontmatter, body } = parseFrontmatter(content, { source: path });
 
 	// Extract frontmatter fields

package/src/exa/mcp-client.ts

@@ -217,8 +217,8 @@ export async function fetchMCPToolSchema(
  * reducing drift when MCP servers add new parameters.
  */
 export class MCPWrappedTool implements CustomTool<TSchema, ExaRenderDetails> {
-	public readonly name: string;
-	public readonly label: string;
+	readonly name: string;
+	readonly label: string;
 
 	constructor(
 		private readonly config: MCPToolWrapperConfig,

package/src/exa/websets.ts

@@ -3,7 +3,7 @@
  *
  * CRUD operations for websets, items, searches, enrichments, and monitoring.
  */
-import { Type } from "@sinclair/typebox";
+import { type TObject, type TProperties, Type } from "@sinclair/typebox";
 import type { CustomTool } from "../extensibility/custom-tools/types";
 import { callWebsetsTool, findApiKey } from "./mcp-client";
 import type { ExaRenderDetails } from "./types";
@@ -13,7 +13,7 @@ function createWebsetTool(
 	name: string,
 	label: string,
 	description: string,
-	parameters: ReturnType<typeof Type.Object>,
+	parameters: TObject<TProperties>,
 	mcpToolName: string,
 ): CustomTool<any, ExaRenderDetails> {
 	return {

package/src/export/html/index.ts

@@ -3,7 +3,7 @@ import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import { APP_NAME } from "../../config";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/theme/theme";
-import { SessionManager } from "../../session/session-manager";
+import { type SessionEntry, type SessionHeader, SessionManager } from "../../session/session-manager";
 // Pre-generated template (created by scripts/generate-template.ts at publish time)
 import { TEMPLATE } from "./template.generated";
 
@@ -92,8 +92,8 @@ async function generateThemeVars(themeName?: string): Promise<string> {
 }
 
 interface SessionData {
-	header: ReturnType<SessionManager["getHeader"]>;
-	entries: ReturnType<SessionManager["getEntries"]>;
+	header: SessionHeader | null;
+	entries: SessionEntry[];
 	leafId: string | null;
 	systemPrompt?: string;
 	tools?: { name: string; description: string }[];

package/src/export/ttsr.ts

@@ -28,29 +28,29 @@ const DEFAULT_SETTINGS: Required<TtsrSettings> = {
 };
 
 export class TtsrManager {
-	private readonly settings: Required<TtsrSettings>;
-	private readonly rules = new Map<string, TtsrEntry>();
-	private readonly injectionRecords = new Map<string, InjectionRecord>();
-	private buffer = "";
-	private messageCount = 0;
+	readonly #settings: Required<TtsrSettings>;
+	readonly #rules = new Map<string, TtsrEntry>();
+	readonly #injectionRecords = new Map<string, InjectionRecord>();
+	#buffer = "";
+	#messageCount = 0;
 
 	constructor(settings?: TtsrSettings) {
-		this.settings = { ...DEFAULT_SETTINGS, ...settings };
+		this.#settings = { ...DEFAULT_SETTINGS, ...settings };
 	}
 
 	/** Check if a rule can be triggered based on repeat settings */
-	private canTrigger(ruleName: string): boolean {
-		const record = this.injectionRecords.get(ruleName);
+	#canTrigger(ruleName: string): boolean {
+		const record = this.#injectionRecords.get(ruleName);
 		if (!record) {
 			return true;
 		}
 
-		if (this.settings.repeatMode === "once") {
+		if (this.#settings.repeatMode === "once") {
 			return false;
 		}
 
-		const gap = this.messageCount - record.lastInjectedAt;
-		return gap >= this.settings.repeatGap;
+		const gap = this.#messageCount - record.lastInjectedAt;
+		return gap >= this.#settings.repeatGap;
 	}
 
 	/** Add a TTSR rule to be monitored */
@@ -59,13 +59,13 @@ export class TtsrManager {
 			return;
 		}
 
-		if (this.rules.has(rule.name)) {
+		if (this.#rules.has(rule.name)) {
 			return;
 		}
 
 		try {
 			const regex = new RegExp(rule.ttsrTrigger);
-			this.rules.set(rule.name, { rule, regex });
+			this.#rules.set(rule.name, { rule, regex });
 			logger.debug("TTSR rule registered", {
 				ruleName: rule.name,
 				pattern: rule.ttsrTrigger,
@@ -83,8 +83,8 @@ export class TtsrManager {
 	check(streamBuffer: string): Rule[] {
 		const matches: Rule[] = [];
 
-		for (const [name, entry] of this.rules) {
-			if (!this.canTrigger(name)) {
+		for (const [name, entry] of this.#rules) {
+			if (!this.#canTrigger(name)) {
 				continue;
 			}
 
@@ -103,24 +103,24 @@ export class TtsrManager {
 	/** Mark rules as injected (won't trigger again until conditions allow) */
 	markInjected(rulesToMark: Rule[]): void {
 		for (const rule of rulesToMark) {
-			this.injectionRecords.set(rule.name, { lastInjectedAt: this.messageCount });
+			this.#injectionRecords.set(rule.name, { lastInjectedAt: this.#messageCount });
 			logger.debug("TTSR rule marked as injected", {
 				ruleName: rule.name,
-				messageCount: this.messageCount,
-				repeatMode: this.settings.repeatMode,
+				messageCount: this.#messageCount,
+				repeatMode: this.#settings.repeatMode,
 			});
 		}
 	}
 
 	/** Get names of all injected rules (for persistence) */
 	getInjectedRuleNames(): string[] {
-		return Array.from(this.injectionRecords.keys());
+		return Array.from(this.#injectionRecords.keys());
 	}
 
 	/** Restore injected state from a list of rule names */
 	restoreInjected(ruleNames: string[]): void {
 		for (const name of ruleNames) {
-			this.injectionRecords.set(name, { lastInjectedAt: 0 });
+			this.#injectionRecords.set(name, { lastInjectedAt: 0 });
 		}
 		if (ruleNames.length > 0) {
 			logger.debug("TTSR injected state restored", { ruleNames });
@@ -129,36 +129,36 @@ export class TtsrManager {
 
 	/** Reset stream buffer (called on new turn) */
 	resetBuffer(): void {
-		this.buffer = "";
+		this.#buffer = "";
 	}
 
 	/** Get current stream buffer */
 	getBuffer(): string {
-		return this.buffer;
+		return this.#buffer;
 	}
 
 	/** Append to stream buffer */
 	appendToBuffer(text: string): void {
-		this.buffer += text;
+		this.#buffer += text;
 	}
 
 	/** Check if any TTSRs are registered */
 	hasRules(): boolean {
-		return this.rules.size > 0;
+		return this.#rules.size > 0;
 	}
 
 	/** Increment message counter (call after each turn) */
 	incrementMessageCount(): void {
-		this.messageCount++;
+		this.#messageCount++;
 	}
 
 	/** Get current message count */
 	getMessageCount(): number {
-		return this.messageCount;
+		return this.#messageCount;
 	}
 
 	/** Get settings */
 	getSettings(): Required<TtsrSettings> {
-		return this.settings;
+		return this.#settings;
 	}
 }

package/src/extensibility/custom-tools/loader.ts

@@ -119,11 +119,11 @@ interface ToolPathWithSource {
 export class CustomToolLoader {
 	tools: LoadedCustomTool[] = [];
 	errors: ToolLoadError[] = [];
-	private sharedApi: CustomToolAPI;
-	private seenNames: Set<string>;
+	#sharedApi: CustomToolAPI;
+	#seenNames: Set<string>;
 
 	constructor(cwd: string, builtInToolNames: string[]) {
-		this.sharedApi = {
+		this.#sharedApi = {
 			cwd,
 			exec: (command: string, args: string[], options?: ExecOptions) =>
 				execCommand(command, args, options?.cwd ?? cwd, options),
@@ -133,12 +133,12 @@ export class CustomToolLoader {
 			typebox,
 			pi: piCodingAgent,
 		};
-		this.seenNames = new Set<string>(builtInToolNames);
+		this.#seenNames = new Set<string>(builtInToolNames);
 	}
 
 	async load(pathsWithSources: ToolPathWithSource[]): Promise<void> {
 		for (const { path: toolPath, source } of pathsWithSources) {
-			const { tools: loadedTools, error } = await loadTool(toolPath, this.sharedApi.cwd, this.sharedApi, source);
+			const { tools: loadedTools, error } = await loadTool(toolPath, this.#sharedApi.cwd, this.#sharedApi, source);
 
 			if (error) {
 				this.errors.push(error);
@@ -148,7 +148,7 @@ export class CustomToolLoader {
 			if (loadedTools) {
 				for (const loadedTool of loadedTools) {
 					// Check for name conflicts
-					if (this.seenNames.has(loadedTool.tool.name)) {
+					if (this.#seenNames.has(loadedTool.tool.name)) {
 						this.errors.push({
 							path: toolPath,
 							error: `Tool name "${loadedTool.tool.name}" conflicts with existing tool`,
@@ -157,7 +157,7 @@ export class CustomToolLoader {
 						continue;
 					}
 
-					this.seenNames.add(loadedTool.tool.name);
+					this.#seenNames.add(loadedTool.tool.name);
 					this.tools.push(loadedTool);
 				}
 			}
@@ -165,8 +165,8 @@ export class CustomToolLoader {
 	}
 
 	setUIContext(uiContext: HookUIContext, hasUI: boolean): void {
-		this.sharedApi.ui = uiContext;
-		this.sharedApi.hasUI = hasUI;
+		this.#sharedApi.ui = uiContext;
+		this.#sharedApi.hasUI = hasUI;
 	}
 }
 

package/src/extensibility/extensions/runner.ts

@@ -153,23 +153,23 @@ const noOpUIContext: ExtensionUIContext = {
 };
 
 export class ExtensionRunner {
-	private uiContext: ExtensionUIContext;
-	private errorListeners: Set<ExtensionErrorListener> = new Set();
-	private getModel: () => Model | undefined = () => undefined;
-	private isIdleFn: () => boolean = () => true;
-	private waitForIdleFn: () => Promise<void> = async () => {};
-	private abortFn: () => void = () => {};
-	private hasPendingMessagesFn: () => boolean = () => false;
-	private getContextUsageFn: () => ContextUsage | undefined = () => undefined;
-	private compactFn: (instructionsOrOptions?: string | CompactOptions) => Promise<void> = async () => {};
-	private getSystemPromptFn: () => string = () => "";
-	private newSessionHandler: NewSessionHandler = async () => ({ cancelled: false });
-	private branchHandler: BranchHandler = async () => ({ cancelled: false });
-	private navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
-	private switchSessionHandler: SwitchSessionHandler = async () => ({ cancelled: false });
-	private reloadHandler: () => Promise<void> = async () => {};
-	private shutdownHandler: ShutdownHandler = () => {};
-	private commandDiagnostics: Array<{ type: string; message: string; path: string }> = [];
+	#uiContext: ExtensionUIContext;
+	#errorListeners: Set<ExtensionErrorListener> = new Set();
+	#getModel: () => Model | undefined = () => undefined;
+	#isIdleFn: () => boolean = () => true;
+	#waitForIdleFn: () => Promise<void> = async () => {};
+	#abortFn: () => void = () => {};
+	#hasPendingMessagesFn: () => boolean = () => false;
+	#getContextUsageFn: () => ContextUsage | undefined = () => undefined;
+	#compactFn: (instructionsOrOptions?: string | CompactOptions) => Promise<void> = async () => {};
+	#getSystemPromptFn: () => string = () => "";
+	#newSessionHandler: NewSessionHandler = async () => ({ cancelled: false });
+	#branchHandler: BranchHandler = async () => ({ cancelled: false });
+	#navigateTreeHandler: NavigateTreeHandler = async () => ({ cancelled: false });
+	#switchSessionHandler: SwitchSessionHandler = async () => ({ cancelled: false });
+	#reloadHandler: () => Promise<void> = async () => {};
+	#shutdownHandler: ShutdownHandler = () => {};
+	#commandDiagnostics: Array<{ type: string; message: string; path: string }> = [];
 
 	constructor(
 		private readonly extensions: Extension[],
@@ -178,7 +178,7 @@ export class ExtensionRunner {
 		private readonly sessionManager: SessionManager,
 		private readonly modelRegistry: ModelRegistry,
 	) {
-		this.uiContext = noOpUIContext;
+		this.#uiContext = noOpUIContext;
 	}
 
 	initialize(
@@ -200,34 +200,34 @@ export class ExtensionRunner {
 		this.runtime.setThinkingLevel = actions.setThinkingLevel;
 
 		// Context actions (required)
-		this.getModel = contextActions.getModel;
-		this.isIdleFn = contextActions.isIdle;
-		this.abortFn = contextActions.abort;
-		this.hasPendingMessagesFn = contextActions.hasPendingMessages;
-		this.shutdownHandler = contextActions.shutdown;
-		this.getSystemPromptFn = contextActions.getSystemPrompt;
+		this.#getModel = contextActions.getModel;
+		this.#isIdleFn = contextActions.isIdle;
+		this.#abortFn = contextActions.abort;
+		this.#hasPendingMessagesFn = contextActions.hasPendingMessages;
+		this.#shutdownHandler = contextActions.shutdown;
+		this.#getSystemPromptFn = contextActions.getSystemPrompt;
 
 		// Command context actions (optional, only for interactive mode)
 		if (commandContextActions) {
-			this.waitForIdleFn = commandContextActions.waitForIdle;
-			this.newSessionHandler = commandContextActions.newSession;
-			this.branchHandler = commandContextActions.branch;
-			this.navigateTreeHandler = commandContextActions.navigateTree;
-			this.switchSessionHandler = commandContextActions.switchSession;
-			this.reloadHandler = commandContextActions.reload;
-			this.getContextUsageFn = commandContextActions.getContextUsage;
-			this.compactFn = commandContextActions.compact;
+			this.#waitForIdleFn = commandContextActions.waitForIdle;
+			this.#newSessionHandler = commandContextActions.newSession;
+			this.#branchHandler = commandContextActions.branch;
+			this.#navigateTreeHandler = commandContextActions.navigateTree;
+			this.#switchSessionHandler = commandContextActions.switchSession;
+			this.#reloadHandler = commandContextActions.reload;
+			this.#getContextUsageFn = commandContextActions.getContextUsage;
+			this.#compactFn = commandContextActions.compact;
 		}
 
-		this.uiContext = uiContext ?? noOpUIContext;
+		this.#uiContext = uiContext ?? noOpUIContext;
 	}
 
 	getUIContext(): ExtensionUIContext {
-		return this.uiContext;
+		return this.#uiContext;
 	}
 
 	hasUI(): boolean {
-		return this.uiContext !== noOpUIContext;
+		return this.#uiContext !== noOpUIContext;
 	}
 
 	getExtensionPaths(): string[] {
@@ -259,7 +259,7 @@ export class ExtensionRunner {
 		this.runtime.flagValues.set(name, value);
 	}
 
-	private static readonly RESERVED_SHORTCUTS = new Set([
+	static readonly #RESERVED_SHORTCUTS = new Set([
 		"ctrl+c",
 		"ctrl+d",
 		"ctrl+z",
@@ -282,7 +282,7 @@ export class ExtensionRunner {
 			for (const [key, shortcut] of ext.shortcuts) {
 				const normalizedKey = key.toLowerCase() as KeyId;
 
-				if (ExtensionRunner.RESERVED_SHORTCUTS.has(normalizedKey)) {
+				if (ExtensionRunner.#RESERVED_SHORTCUTS.has(normalizedKey)) {
 					logger.warn("Extension shortcut conflicts with built-in shortcut", {
 						key,
 						extensionPath: shortcut.extensionPath,
@@ -305,12 +305,12 @@ export class ExtensionRunner {
 	}
 
 	onError(listener: ExtensionErrorListener): () => void {
-		this.errorListeners.add(listener);
-		return () => this.errorListeners.delete(listener);
+		this.#errorListeners.add(listener);
+		return () => this.#errorListeners.delete(listener);
 	}
 
 	emitError(error: ExtensionError): void {
-		for (const listener of this.errorListeners) {
+		for (const listener of this.#errorListeners) {
 			listener(error);
 		}
 	}
@@ -336,14 +336,14 @@ export class ExtensionRunner {
 	}
 
 	getRegisteredCommands(reserved?: Set<string>): RegisteredCommand[] {
-		this.commandDiagnostics = [];
+		this.#commandDiagnostics = [];
 
 		const commands: RegisteredCommand[] = [];
 		for (const ext of this.extensions) {
 			for (const command of ext.commands.values()) {
 				if (reserved?.has(command.name)) {
 					const message = `Extension command '${command.name}' from ${ext.path} conflicts with built-in commands. Skipping.`;
-					this.commandDiagnostics.push({ type: "warning", message, path: ext.path });
+					this.#commandDiagnostics.push({ type: "warning", message, path: ext.path });
 					if (!this.hasUI()) {
 						logger.warn(message);
 					}
@@ -357,7 +357,7 @@ export class ExtensionRunner {
 	}
 
 	getCommandDiagnostics(): Array<{ type: string; message: string; path: string }> {
-		return this.commandDiagnostics;
+		return this.#commandDiagnostics;
 	}
 
 	getCommand(name: string): RegisteredCommand | undefined {
@@ -371,11 +371,11 @@ export class ExtensionRunner {
 	}
 
 	createContext(): ExtensionContext {
-		const getModel = this.getModel;
+		const getModel = this.#getModel;
 		return {
-			ui: this.uiContext,
-			getContextUsage: () => this.getContextUsageFn(),
-			compact: instructionsOrOptions => this.compactFn(instructionsOrOptions),
+			ui: this.#uiContext,
+			getContextUsage: () => this.#getContextUsageFn(),
+			compact: instructionsOrOptions => this.#compactFn(instructionsOrOptions),
 			hasUI: this.hasUI(),
 			cwd: this.cwd,
 			sessionManager: this.sessionManager,
@@ -383,12 +383,12 @@ export class ExtensionRunner {
 			get model() {
 				return getModel();
 			},
-			isIdle: () => this.isIdleFn(),
-			abort: () => this.abortFn(),
-			hasPendingMessages: () => this.hasPendingMessagesFn(),
-			shutdown: () => this.shutdownHandler(),
-			getSystemPrompt: () => this.getSystemPromptFn(),
-			hasQueuedMessages: () => this.hasPendingMessagesFn(), // deprecated alias
+			isIdle: () => this.#isIdleFn(),
+			abort: () => this.#abortFn(),
+			hasPendingMessages: () => this.#hasPendingMessagesFn(),
+			shutdown: () => this.#shutdownHandler(),
+			getSystemPrompt: () => this.#getSystemPromptFn(),
+			hasQueuedMessages: () => this.#hasPendingMessagesFn(), // deprecated alias
 		};
 	}
 
@@ -396,24 +396,24 @@ export class ExtensionRunner {
 	 * Request a graceful shutdown. Called by extension tools and event handlers.
 	 */
 	shutdown(): void {
-		this.shutdownHandler();
+		this.#shutdownHandler();
 	}
 
 	createCommandContext(): ExtensionCommandContext {
 		return {
 			...this.createContext(),
-			getContextUsage: () => this.getContextUsageFn(),
-			waitForIdle: () => this.waitForIdleFn(),
-			newSession: options => this.newSessionHandler(options),
-			branch: entryId => this.branchHandler(entryId),
-			navigateTree: (targetId, options) => this.navigateTreeHandler(targetId, options),
-			switchSession: sessionPath => this.switchSessionHandler(sessionPath),
-			reload: () => this.reloadHandler(),
-			compact: instructionsOrOptions => this.compactFn(instructionsOrOptions),
+			getContextUsage: () => this.#getContextUsageFn(),
+			waitForIdle: () => this.#waitForIdleFn(),
+			newSession: options => this.#newSessionHandler(options),
+			branch: entryId => this.#branchHandler(entryId),
+			navigateTree: (targetId, options) => this.#navigateTreeHandler(targetId, options),
+			switchSession: sessionPath => this.#switchSessionHandler(sessionPath),
+			reload: () => this.#reloadHandler(),
+			compact: instructionsOrOptions => this.#compactFn(instructionsOrOptions),
 		};
 	}
 
-	private isSessionBeforeEvent(event: RunnerEmitEvent): event is SessionBeforeEvent {
+	#isSessionBeforeEvent(event: RunnerEmitEvent): event is SessionBeforeEvent {
 		return (
 			event.type === "session_before_switch" ||
 			event.type === "session_before_branch" ||
@@ -434,7 +434,7 @@ export class ExtensionRunner {
 				try {
 					const handlerResult = await handler(event, ctx);
 
-					if (this.isSessionBeforeEvent(event) && handlerResult) {
+					if (this.#isSessionBeforeEvent(event) && handlerResult) {
 						result = handlerResult as SessionBeforeEventResult;
 						if (result.cancel) {
 							return result as RunnerEmitResult<TEvent>;