@ashx-j/lunr 0.2.21 → 0.2.22

package/dist/node-runtime/{chunk-Y5KOEMBH.js → chunk-IQIEU7SB.js}

@@ -8,12 +8,12 @@ import {
 import {
   parseFrontmatter
 } from "./chunk-QFWG2RVL.js";
+import {
+  SettingsManager
+} from "./chunk-WADV2VDS.js";
 import {
   minimatch
 } from "./chunk-CGBXPL3E.js";
-import {
-  SettingsManager
-} from "./chunk-WLLDXJRT.js";
 import {
   getGlobalInstructionsPath,
   loadSelectedUserInstructions
@@ -23,9 +23,8 @@ import {
   resetTimings
 } from "./chunk-PVCDKGR6.js";
 import {
-  loadThemeFromPath,
-  theme
-} from "./chunk-RNBHABBA.js";
+  loadThemeFromPath
+} from "./chunk-7QWNYZDI.js";
 import {
   CONFIG_DIR_NAME,
   canonicalizePath,
@@ -6652,9 +6651,9 @@ var DefaultResourceLoader = class {
       themesResult = { themes: deduped.themes, diagnostics: [...loaded.diagnostics, ...deduped.diagnostics] };
     }
     let resolvedThemes = this.themesOverride ? this.themesOverride(themesResult) : themesResult;
-    this.themes = resolvedThemes.themes.map((theme2) => {
-      let sourcePath = theme2.sourcePath;
-      return theme2.sourceInfo = sourcePath ? this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ?? theme2.sourceInfo ?? this.getDefaultSourceInfoForPath(sourcePath) : theme2.sourceInfo, theme2;
+    this.themes = resolvedThemes.themes.map((theme) => {
+      let sourcePath = theme.sourcePath;
+      return theme.sourceInfo = sourcePath ? this.findSourceInfoForPath(sourcePath, this.extensionThemeSourceInfos, metadataByPath) ?? theme.sourceInfo ?? this.getDefaultSourceInfoForPath(sourcePath) : theme.sourceInfo, theme;
     }), this.themeDiagnostics = resolvedThemes.diagnostics;
   }
   applyExtensionSourceInfo(extensions, metadataByPath) {
@@ -6878,667 +6877,6 @@ var DefaultResourceLoader = class {
   }
 };
 
-// packages/coding-agent/dist/core/extensions/runner.js
-var RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
-  "app.interrupt",
-  "app.clear",
-  "app.exit",
-  "app.suspend",
-  "app.thinking.cycle",
-  "app.mode.cycle",
-  "app.model.cycleForward",
-  "app.model.cycleBackward",
-  "app.model.select",
-  "app.tools.expand",
-  "app.thinking.toggle",
-  "app.editor.external",
-  "app.message.copy",
-  "app.message.followUp",
-  "tui.input.submit",
-  "tui.select.confirm",
-  "tui.select.cancel",
-  "tui.input.copy",
-  "tui.editor.deleteToLineEnd"
-], buildBuiltinKeybindings = (resolvedKeybindings) => {
-  let builtinKeybindings = {};
-  for (let [keybinding, keys] of Object.entries(resolvedKeybindings)) {
-    if (keys === void 0)
-      continue;
-    let keyList = Array.isArray(keys) ? keys : [keys], restrictOverride = RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS.includes(keybinding);
-    for (let key of keyList) {
-      let normalizedKey = key.toLowerCase();
-      builtinKeybindings[normalizedKey]?.restrictOverride && !restrictOverride || (builtinKeybindings[normalizedKey] = {
-        keybinding,
-        restrictOverride
-      });
-    }
-  }
-  return builtinKeybindings;
-};
-async function emitSessionShutdownEvent(extensionRunner, event) {
-  return extensionRunner.hasHandlers("session_shutdown") ? (await extensionRunner.emit(event), !0) : !1;
-}
-async function emitProjectTrustEvent(extensionsResult, event, ctx) {
-  let errors = [];
-  for (let ext of extensionsResult.extensions) {
-    let handlers = ext.handlers.get("project_trust");
-    if (!(!handlers || handlers.length === 0))
-      for (let handler of handlers)
-        try {
-          let handlerResult = await handler(event, ctx);
-          if (handlerResult.trusted === "undecided")
-            continue;
-          return { result: handlerResult, errors };
-        } catch (error) {
-          errors.push({
-            extensionPath: ext.path,
-            event: event.type,
-            error: error instanceof Error ? error.message : String(error),
-            stack: error instanceof Error ? error.stack : void 0
-          });
-        }
-  }
-  return { errors };
-}
-var noOpUIContext = {
-  select: async () => {
-  },
-  confirm: async () => !1,
-  input: async () => {
-  },
-  notify: () => {
-  },
-  onTerminalInput: () => () => {
-  },
-  setStatus: () => {
-  },
-  setWorkingMessage: () => {
-  },
-  setWorkingVisible: () => {
-  },
-  setWorkingIndicator: () => {
-  },
-  setHiddenThinkingLabel: () => {
-  },
-  setWidget: () => {
-  },
-  setFooter: () => {
-  },
-  setHeader: () => {
-  },
-  setTitle: () => {
-  },
-  custom: async () => {
-  },
-  pasteToEditor: () => {
-  },
-  setEditorText: () => {
-  },
-  getEditorText: () => "",
-  editor: async () => {
-  },
-  addAutocompleteProvider: () => {
-  },
-  setEditorComponent: () => {
-  },
-  getEditorComponent: () => {
-  },
-  get theme() {
-    return theme;
-  },
-  getAllThemes: () => [],
-  getTheme: () => {
-  },
-  setTheme: (_theme) => ({ success: !1, error: "UI not available" }),
-  getToolsExpanded: () => !1,
-  setToolsExpanded: () => {
-  }
-}, ExtensionRunner = class {
-  extensions;
-  runtime;
-  uiContext;
-  mode = "print";
-  cwd;
-  sessionManager;
-  modelRegistry;
-  errorListeners = /* @__PURE__ */ new Set();
-  getModel = () => {
-  };
-  isIdleFn = () => !0;
-  isProjectTrustedFn = () => !0;
-  getSignalFn = () => {
-  };
-  waitForIdleFn = async () => {
-  };
-  abortFn = () => {
-  };
-  hasPendingMessagesFn = () => !1;
-  getContextUsageFn = () => {
-  };
-  compactFn = () => {
-  };
-  getSystemPromptFn = () => "";
-  getSystemPromptOptionsFn = () => ({ cwd: this.cwd });
-  newSessionHandler = async () => ({ cancelled: !1 });
-  forkHandler = async () => ({ cancelled: !1 });
-  navigateTreeHandler = async () => ({ cancelled: !1 });
-  switchSessionHandler = async () => ({ cancelled: !1 });
-  reloadHandler = async () => {
-  };
-  shutdownHandler = () => {
-  };
-  shortcutDiagnostics = [];
-  commandDiagnostics = [];
-  staleMessage;
-  constructor(extensions, runtime, cwd, sessionManager, modelRegistry) {
-    this.extensions = extensions, this.runtime = runtime, this.uiContext = noOpUIContext, this.cwd = cwd, this.sessionManager = sessionManager, this.modelRegistry = modelRegistry;
-  }
-  bindCore(actions, contextActions, providerActions) {
-    this.runtime.sendMessage = actions.sendMessage, this.runtime.sendUserMessage = actions.sendUserMessage, this.runtime.appendEntry = actions.appendEntry, this.runtime.setSessionName = actions.setSessionName, this.runtime.getSessionName = actions.getSessionName, this.runtime.setLabel = actions.setLabel, this.runtime.getActiveTools = actions.getActiveTools, this.runtime.getAllTools = actions.getAllTools, this.runtime.setActiveTools = actions.setActiveTools, this.runtime.refreshTools = actions.refreshTools, this.runtime.getCommands = actions.getCommands, this.runtime.setModel = actions.setModel, this.runtime.getThinkingLevel = actions.getThinkingLevel, this.runtime.setThinkingLevel = actions.setThinkingLevel, this.getModel = contextActions.getModel, this.isIdleFn = contextActions.isIdle, this.isProjectTrustedFn = contextActions.isProjectTrusted, this.getSignalFn = contextActions.getSignal, this.abortFn = contextActions.abort, this.hasPendingMessagesFn = contextActions.hasPendingMessages, this.shutdownHandler = contextActions.shutdown, this.getContextUsageFn = contextActions.getContextUsage, this.compactFn = contextActions.compact, this.getSystemPromptFn = contextActions.getSystemPrompt, this.getSystemPromptOptionsFn = contextActions.getSystemPromptOptions ?? (() => ({ cwd: this.cwd }));
-    for (let { name, config, extensionPath } of this.runtime.pendingProviderRegistrations)
-      try {
-        providerActions?.registerProvider ? providerActions.registerProvider(name, config) : this.modelRegistry.registerProvider(name, config);
-      } catch (err) {
-        this.emitError({
-          extensionPath,
-          event: "register_provider",
-          error: err instanceof Error ? err.message : String(err),
-          stack: err instanceof Error ? err.stack : void 0
-        });
-      }
-    this.runtime.pendingProviderRegistrations = [], this.runtime.registerProvider = (name, config) => {
-      if (providerActions?.registerProvider) {
-        providerActions.registerProvider(name, config);
-        return;
-      }
-      this.modelRegistry.registerProvider(name, config);
-    }, this.runtime.unregisterProvider = (name) => {
-      if (providerActions?.unregisterProvider) {
-        providerActions.unregisterProvider(name);
-        return;
-      }
-      this.modelRegistry.unregisterProvider(name);
-    };
-  }
-  bindCommandContext(actions) {
-    if (actions) {
-      this.waitForIdleFn = actions.waitForIdle, this.newSessionHandler = actions.newSession, this.forkHandler = actions.fork, this.navigateTreeHandler = actions.navigateTree, this.switchSessionHandler = actions.switchSession, this.reloadHandler = actions.reload;
-      return;
-    }
-    this.waitForIdleFn = async () => {
-    }, this.newSessionHandler = async () => ({ cancelled: !1 }), this.forkHandler = async () => ({ cancelled: !1 }), this.navigateTreeHandler = async () => ({ cancelled: !1 }), this.switchSessionHandler = async () => ({ cancelled: !1 }), this.reloadHandler = async () => {
-    };
-  }
-  setUIContext(uiContext, mode = "print") {
-    this.uiContext = uiContext ?? noOpUIContext, this.mode = mode;
-  }
-  getUIContext() {
-    return this.uiContext;
-  }
-  hasUI() {
-    return this.uiContext !== noOpUIContext;
-  }
-  getExtensionPaths() {
-    return this.extensions.map((e) => e.path);
-  }
-  /** Append already-loaded extensions to this runner. Bindings stay on the existing runtime. */
-  appendExtensions(extensions) {
-    let existing = new Set(this.extensions), existingPaths = new Set(this.extensions.map((extension) => extension.path));
-    for (let extension of extensions)
-      existing.has(extension) || existingPaths.has(extension.path) || (this.extensions.push(extension), existing.add(extension), existingPaths.add(extension.path));
-  }
-  /** Get all registered tools from all extensions (first registration per name wins). */
-  getAllRegisteredTools() {
-    let toolsByName = /* @__PURE__ */ new Map();
-    for (let ext of this.extensions)
-      for (let tool of ext.tools.values())
-        toolsByName.has(tool.definition.name) || toolsByName.set(tool.definition.name, tool);
-    return Array.from(toolsByName.values());
-  }
-  /** Get a tool definition by name. Returns undefined if not found. */
-  getToolDefinition(toolName) {
-    for (let ext of this.extensions) {
-      let tool = ext.tools.get(toolName);
-      if (tool)
-        return tool.definition;
-    }
-  }
-  getFlags() {
-    let allFlags = /* @__PURE__ */ new Map();
-    for (let ext of this.extensions)
-      for (let [name, flag] of ext.flags)
-        allFlags.has(name) || allFlags.set(name, flag);
-    return allFlags;
-  }
-  setFlagValue(name, value) {
-    this.runtime.flagValues.set(name, value);
-  }
-  getFlagValues() {
-    return new Map(this.runtime.flagValues);
-  }
-  getShortcuts(resolvedKeybindings) {
-    this.shortcutDiagnostics = [];
-    let builtinKeybindings = buildBuiltinKeybindings(resolvedKeybindings), extensionShortcuts = /* @__PURE__ */ new Map(), addDiagnostic = (message, extensionPath) => {
-      this.shortcutDiagnostics.push({ type: "warning", message, path: extensionPath }), this.hasUI() || console.warn(message);
-    };
-    for (let ext of this.extensions)
-      for (let [key, shortcut] of ext.shortcuts) {
-        let normalizedKey = key.toLowerCase(), builtInKeybinding = builtinKeybindings[normalizedKey];
-        if (builtInKeybinding?.restrictOverride === !0) {
-          addDiagnostic(`Extension shortcut '${key}' from ${shortcut.extensionPath} conflicts with built-in shortcut. Skipping.`, shortcut.extensionPath);
-          continue;
-        }
-        builtInKeybinding?.restrictOverride === !1 && addDiagnostic(`Extension shortcut conflict: '${key}' is built-in shortcut for ${builtInKeybinding.keybinding} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath);
-        let existingExtensionShortcut = extensionShortcuts.get(normalizedKey);
-        existingExtensionShortcut && addDiagnostic(`Extension shortcut conflict: '${key}' registered by both ${existingExtensionShortcut.extensionPath} and ${shortcut.extensionPath}. Using ${shortcut.extensionPath}.`, shortcut.extensionPath), extensionShortcuts.set(normalizedKey, shortcut);
-      }
-    return extensionShortcuts;
-  }
-  getShortcutDiagnostics() {
-    return this.shortcutDiagnostics;
-  }
-  invalidate(message = "This extension ctx is stale after session replacement or reload. Do not use a captured pi or command ctx after ctx.newSession(), ctx.fork(), ctx.switchSession(), or ctx.reload(). For newSession, fork, and switchSession, move post-replacement work into withSession and use the ctx passed to withSession. For reload, do not use the old ctx after await ctx.reload().") {
-    this.staleMessage || (this.staleMessage = message, this.runtime.invalidate(message));
-  }
-  assertActive() {
-    if (this.staleMessage)
-      throw new Error(this.staleMessage);
-  }
-  onError(listener) {
-    return this.errorListeners.add(listener), () => this.errorListeners.delete(listener);
-  }
-  emitError(error) {
-    for (let listener of this.errorListeners)
-      listener(error);
-  }
-  hasHandlers(eventType) {
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get(eventType);
-      if (handlers && handlers.length > 0)
-        return !0;
-    }
-    return !1;
-  }
-  getMessageRenderer(customType) {
-    for (let ext of this.extensions) {
-      let renderer = ext.messageRenderers.get(customType);
-      if (renderer)
-        return renderer;
-    }
-  }
-  getEntryRenderer(customType) {
-    for (let ext of this.extensions) {
-      let renderer = ext.entryRenderers?.get(customType);
-      if (renderer)
-        return renderer;
-    }
-  }
-  resolveRegisteredCommands() {
-    let commands = [], counts = /* @__PURE__ */ new Map();
-    for (let ext of this.extensions)
-      for (let command of ext.commands.values())
-        commands.push(command), counts.set(command.name, (counts.get(command.name) ?? 0) + 1);
-    let seen = /* @__PURE__ */ new Map(), takenInvocationNames = /* @__PURE__ */ new Set();
-    return commands.map((command) => {
-      let occurrence = (seen.get(command.name) ?? 0) + 1;
-      seen.set(command.name, occurrence);
-      let invocationName = (counts.get(command.name) ?? 0) > 1 ? `${command.name}:${occurrence}` : command.name;
-      if (takenInvocationNames.has(invocationName)) {
-        let suffix = occurrence;
-        do
-          suffix++, invocationName = `${command.name}:${suffix}`;
-        while (takenInvocationNames.has(invocationName));
-      }
-      return takenInvocationNames.add(invocationName), {
-        ...command,
-        invocationName
-      };
-    });
-  }
-  getModelRegistry() {
-    return this.modelRegistry;
-  }
-  getRegisteredCommands() {
-    return this.commandDiagnostics = [], this.resolveRegisteredCommands();
-  }
-  getCommandDiagnostics() {
-    return this.commandDiagnostics;
-  }
-  getCommand(name) {
-    return this.resolveRegisteredCommands().find((command) => command.invocationName === name);
-  }
-  /**
-   * Request a graceful shutdown. Called by extension tools and event handlers.
-   * The actual shutdown behavior is provided by the mode via bindExtensions().
-   */
-  shutdown() {
-    this.shutdownHandler();
-  }
-  getActiveTools() {
-    return this.assertActive(), this.runtime.getActiveTools();
-  }
-  /**
-   * Create an ExtensionContext for use in event handlers and tool execution.
-   * Context values are resolved at call time, so changes via bindCore/bindUI are reflected.
-   */
-  createContext() {
-    let runner = this, getModel = this.getModel;
-    return {
-      get ui() {
-        return runner.assertActive(), runner.uiContext;
-      },
-      get mode() {
-        return runner.assertActive(), runner.mode;
-      },
-      get hasUI() {
-        return runner.assertActive(), runner.hasUI();
-      },
-      get cwd() {
-        return runner.assertActive(), runner.cwd;
-      },
-      get sessionManager() {
-        return runner.assertActive(), runner.sessionManager;
-      },
-      get modelRegistry() {
-        return runner.assertActive(), runner.modelRegistry;
-      },
-      get model() {
-        return runner.assertActive(), getModel();
-      },
-      isIdle: () => (runner.assertActive(), runner.isIdleFn()),
-      isProjectTrusted: () => (runner.assertActive(), runner.isProjectTrustedFn()),
-      get signal() {
-        return runner.assertActive(), runner.getSignalFn();
-      },
-      abort: () => {
-        runner.assertActive(), runner.abortFn();
-      },
-      hasPendingMessages: () => (runner.assertActive(), runner.hasPendingMessagesFn()),
-      shutdown: () => {
-        runner.assertActive(), runner.shutdownHandler();
-      },
-      getContextUsage: () => (runner.assertActive(), runner.getContextUsageFn()),
-      compact: (options) => {
-        runner.assertActive(), runner.compactFn(options);
-      },
-      getSystemPrompt: () => (runner.assertActive(), runner.getSystemPromptFn())
-    };
-  }
-  createCommandContext() {
-    let context = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
-    return context.getSystemPromptOptions = () => (this.assertActive(), this.getSystemPromptOptionsFn()), context.waitForIdle = () => (this.assertActive(), this.waitForIdleFn()), context.newSession = (options) => (this.assertActive(), this.newSessionHandler(options)), context.fork = (entryId, options) => (this.assertActive(), this.forkHandler(entryId, options)), context.navigateTree = (targetId, options) => (this.assertActive(), this.navigateTreeHandler(targetId, options)), context.switchSession = (sessionPath, options) => (this.assertActive(), this.switchSessionHandler(sessionPath, options)), context.reload = () => (this.assertActive(), this.reloadHandler()), context;
-  }
-  isSessionBeforeEvent(event) {
-    return event.type === "session_before_switch" || event.type === "session_before_fork" || event.type === "session_before_compact" || event.type === "session_before_tree";
-  }
-  async emit(event) {
-    let ctx = this.createContext(), result;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get(event.type);
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler(event, ctx);
-            if (this.isSessionBeforeEvent(event) && handlerResult && (result = handlerResult, result.cancel))
-              return result;
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: event.type,
-              error: message,
-              stack
-            });
-          }
-    }
-    return result;
-  }
-  async emitMessageEnd(event) {
-    let ctx = this.createContext(), currentMessage = event.message, modified = !1;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("message_end");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let currentEvent = { ...event, message: currentMessage }, handlerResult = await handler(currentEvent, ctx);
-            if (!handlerResult?.message)
-              continue;
-            if (handlerResult.message.role !== currentMessage.role) {
-              this.emitError({
-                extensionPath: ext.path,
-                event: "message_end",
-                error: "message_end handlers must return a message with the same role"
-              });
-              continue;
-            }
-            currentMessage = handlerResult.message, modified = !0;
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "message_end",
-              error: message,
-              stack
-            });
-          }
-    }
-    return modified ? currentMessage : void 0;
-  }
-  async emitToolResult(event) {
-    let ctx = this.createContext(), currentEvent = { ...event }, modified = !1;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("tool_result");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler(currentEvent, ctx);
-            if (!handlerResult)
-              continue;
-            handlerResult.content !== void 0 && (currentEvent.content = handlerResult.content, modified = !0), handlerResult.details !== void 0 && (currentEvent.details = handlerResult.details, modified = !0), handlerResult.isError !== void 0 && (currentEvent.isError = handlerResult.isError, modified = !0);
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "tool_result",
-              error: message,
-              stack
-            });
-          }
-    }
-    if (modified)
-      return {
-        content: currentEvent.content,
-        details: currentEvent.details,
-        isError: currentEvent.isError
-      };
-  }
-  async emitToolCall(event) {
-    let ctx = this.createContext(), result;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("tool_call");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers) {
-          let handlerResult = await handler(event, ctx);
-          if (handlerResult && (result = handlerResult, result.block))
-            return result;
-        }
-    }
-    return result;
-  }
-  async emitUserBash(event) {
-    let ctx = this.createContext();
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("user_bash");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler(event, ctx);
-            if (handlerResult)
-              return handlerResult;
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "user_bash",
-              error: message,
-              stack
-            });
-          }
-    }
-  }
-  async emitContext(messages) {
-    let ctx = this.createContext(), currentMessages = structuredClone(messages);
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("context");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler({ type: "context", messages: currentMessages }, ctx);
-            handlerResult && handlerResult.messages && (currentMessages = handlerResult.messages);
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "context",
-              error: message,
-              stack
-            });
-          }
-    }
-    return currentMessages;
-  }
-  async emitBeforeProviderRequest(payload) {
-    let ctx = this.createContext(), currentPayload = payload;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("before_provider_request");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler({
-              type: "before_provider_request",
-              payload: currentPayload
-            }, ctx);
-            handlerResult !== void 0 && (currentPayload = handlerResult);
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "before_provider_request",
-              error: message,
-              stack
-            });
-          }
-    }
-    return currentPayload;
-  }
-  async emitBeforeProviderHeaders(headers) {
-    let ctx = this.createContext();
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("before_provider_headers");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            await handler({
-              type: "before_provider_headers",
-              headers
-            }, ctx);
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "before_provider_headers",
-              error: message,
-              stack
-            });
-          }
-    }
-    return headers;
-  }
-  async emitBeforeAgentStart(prompt, images, systemPrompt, systemPromptOptions) {
-    let currentSystemPrompt = systemPrompt, ctx = Object.defineProperties({}, Object.getOwnPropertyDescriptors(this.createContext()));
-    ctx.getSystemPrompt = () => (this.assertActive(), currentSystemPrompt);
-    let messages = [], systemPromptModified = !1;
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("before_agent_start");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let handlerResult = await handler({
-              type: "before_agent_start",
-              prompt,
-              images,
-              systemPrompt: currentSystemPrompt,
-              systemPromptOptions
-            }, ctx);
-            if (handlerResult) {
-              let result = handlerResult;
-              result.message && messages.push(result.message), result.systemPrompt !== void 0 && (currentSystemPrompt = result.systemPrompt, systemPromptModified = !0);
-            }
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "before_agent_start",
-              error: message,
-              stack
-            });
-          }
-    }
-    if (messages.length > 0 || systemPromptModified)
-      return {
-        messages: messages.length > 0 ? messages : void 0,
-        systemPrompt: systemPromptModified ? currentSystemPrompt : void 0
-      };
-  }
-  async emitResourcesDiscover(cwd, reason) {
-    let ctx = this.createContext(), skillPaths = [], promptPaths = [], themePaths = [];
-    for (let ext of this.extensions) {
-      let handlers = ext.handlers.get("resources_discover");
-      if (!(!handlers || handlers.length === 0))
-        for (let handler of handlers)
-          try {
-            let result = await handler({ type: "resources_discover", cwd, reason }, ctx);
-            result?.skillPaths?.length && skillPaths.push(...result.skillPaths.map((path2) => ({ path: path2, extensionPath: ext.path }))), result?.promptPaths?.length && promptPaths.push(...result.promptPaths.map((path2) => ({ path: path2, extensionPath: ext.path }))), result?.themePaths?.length && themePaths.push(...result.themePaths.map((path2) => ({ path: path2, extensionPath: ext.path })));
-          } catch (err) {
-            let message = err instanceof Error ? err.message : String(err), stack = err instanceof Error ? err.stack : void 0;
-            this.emitError({
-              extensionPath: ext.path,
-              event: "resources_discover",
-              error: message,
-              stack
-            });
-          }
-    }
-    return { skillPaths, promptPaths, themePaths };
-  }
-  /** Emit input event. Transforms chain, "handled" short-circuits. */
-  async emitInput(text, images, source, streamingBehavior) {
-    let ctx = this.createContext(), currentText = text, currentImages = images;
-    for (let ext of this.extensions)
-      for (let handler of ext.handlers.get("input") ?? [])
-        try {
-          let result = await handler({
-            type: "input",
-            text: currentText,
-            images: currentImages,
-            source,
-            streamingBehavior
-          }, ctx);
-          if (result?.action === "handled")
-            return result;
-          result?.action === "transform" && (currentText = result.text, currentImages = result.images ?? currentImages);
-        } catch (err) {
-          this.emitError({
-            extensionPath: ext.path,
-            event: "input",
-            error: err instanceof Error ? err.message : String(err),
-            stack: err instanceof Error ? err.stack : void 0
-          });
-        }
-    return currentText !== text || currentImages !== images ? { action: "transform", text: currentText, images: currentImages } : { action: "continue" };
-  }
-};
-
 export {
   createEventBus,
   createSyntheticSourceInfo,
@@ -7551,8 +6889,5 @@ export {
   formatSkillsForPrompt,
   loadSkills,
   loadProjectContextFiles,
-  DefaultResourceLoader,
-  emitSessionShutdownEvent,
-  emitProjectTrustEvent,
-  ExtensionRunner
+  DefaultResourceLoader
 };