@fresh-editor/fresh-editor 0.2.25 → 0.3.1

package/plugins/lua-lsp.ts

@@ -49,7 +49,10 @@ let luaLspError: { serverCommand: string; message: string } | null = null;
 /**
  * Handle LSP server errors for Lua
  */
-function on_lua_lsp_server_error(data: LspServerErrorData): void {
+
+
+// Register hook for LSP server errors
+editor.on("lsp_server_error", (data) => {
   // Only handle Lua language errors
   if (data.language !== "lua") {
     return;
@@ -71,18 +74,15 @@ function on_lua_lsp_server_error(data: LspServerErrorData): void {
   } else {
     editor.setStatus(`Lua LSP error: ${data.message}`);
   }
-}
-registerHandler("on_lua_lsp_server_error", on_lua_lsp_server_error);
-
-// Register hook for LSP server errors
-editor.on("lsp_server_error", "on_lua_lsp_server_error");
+});
 
 /**
  * Handle status bar click when there's a Lua LSP error
  */
-function on_lua_lsp_status_clicked(
-  data: LspStatusClickedData
-): void {
+
+
+// Register hook for status bar clicks
+editor.on("lsp_status_clicked", (data) => {
   // Only handle Lua language clicks when there's an error
   if (data.language !== "lua" || !luaLspError) {
     return;
@@ -103,18 +103,15 @@ function on_lua_lsp_status_clicked(
       { id: "dismiss", label: "Dismiss (ESC)" },
     ],
   });
-}
-registerHandler("on_lua_lsp_status_clicked", on_lua_lsp_status_clicked);
-
-// Register hook for status bar clicks
-editor.on("lsp_status_clicked", "on_lua_lsp_status_clicked");
+});
 
 /**
  * Handle action popup results for Lua LSP help
  */
-function on_lua_lsp_action_result(
-  data: ActionPopupResultData
-): void {
+
+
+// Register hook for action popup results
+editor.on("action_popup_result", (data) => {
   // Only handle our popup
   if (data.popup_id !== "lua-lsp-help") {
     return;
@@ -152,10 +149,6 @@ function on_lua_lsp_action_result(
     default:
       editor.debug(`lua-lsp: Unknown action: ${data.action_id}`);
   }
-}
-registerHandler("on_lua_lsp_action_result", on_lua_lsp_action_result);
-
-// Register hook for action popup results
-editor.on("action_popup_result", "on_lua_lsp_action_result");
+});
 
 editor.debug("lua-lsp: Plugin loaded");

package/plugins/markdown_compose.ts

@@ -966,6 +966,23 @@ function concealedText(text: string): string {
 
 const MIN_COL_W = 3;
 
+/**
+ * Return the effective compose width for layout: the configured compose
+ * width clamped to the available viewport width.
+ *
+ * When `config.composeWidth` is explicitly set (e.g. 80) but the editor
+ * content area is smaller (e.g. after the File Explorer sidebar opens),
+ * using the configured value verbatim overflows the viewport. The Rust
+ * render layer already clamps the compose area the same way in
+ * `calculate_compose_layout`; plugin-side computations (table column
+ * allocation, soft-wrap width) need to match.
+ */
+function effectiveComposeWidth(viewportWidth: number): number {
+  const cw = config.composeWidth;
+  if (cw == null) return viewportWidth;
+  return Math.min(cw, viewportWidth);
+}
+
 /**
  * W3C-inspired column width distribution.
  * Constrains columns to fit within `available` width, distributing space
@@ -1142,6 +1159,26 @@ function processLineConceals(
         if (lineContent[i] === '|') pipePositions.push(i);
       }
 
+      // Precompute which cells will be truncated. Per-character conceals
+      // that land inside a truncated cell must be suppressed — the cell-
+      // wide truncate conceal already renders the replacement. When both
+      // fire, the per-char conceal at the cell's first byte emits its
+      // replacement, and the cell-wide conceal emits its replacement one
+      // byte later, producing a cell one character wider than allocated.
+      const truncatedCellCharRanges: Array<{start: number; end: number}> = [];
+      if (!cursorStrictlyOnLine && colWidths) {
+        for (let ci = 0; ci < Math.min(cells.length, colWidths.length); ci++) {
+          const cellText = concealedText(cells[ci]);
+          if (cellText.length > colWidths[ci]) {
+            const prevPipe = pipePositions[ci];
+            const nextPipe = pipePositions[ci + 1];
+            if (prevPipe !== undefined && nextPipe !== undefined) {
+              truncatedCellCharRanges.push({ start: prevPipe + 1, end: nextPipe });
+            }
+          }
+        }
+      }
+
       // Track which pipe index we're on (0 = leading pipe)
       let pipeIdx = 0;
       for (let i = 0; i < lineContent.length; i++) {
@@ -1161,11 +1198,15 @@ function processLineConceals(
             const allocatedWidth = colWidths[cellIdx];
 
             if (cellWidth > allocatedWidth) {
-              // Truncate: conceal entire cell content and replace with truncated text
+              // Truncate: conceal entire cell content and replace with truncated text.
+              // Separator rows use box-drawing ─ to match the non-truncated path
+              // (per-char conceals replace source `-` with ─ and pad via pipe replacement).
               const prevPipeCharPos = pipePositions[pipeIdx - 1];
               const cellByteStart = charToByte(lineContent, prevPipeCharPos + 1, byteStart);
               const cellByteEnd = pipeByte;
-              const truncated = cellText.slice(0, allocatedWidth - 1) + '-';
+              const truncated = isSeparator
+                ? '─'.repeat(allocatedWidth)
+                : cellText.slice(0, allocatedWidth - 1) + '-';
               editor.addConceal(bufferId, "md-syntax", cellByteStart, cellByteEnd, truncated);
               truncatedByteRanges.push({start: cellByteStart, end: cellByteEnd});
             } else {
@@ -1188,6 +1229,10 @@ function processLineConceals(
           }
           pipeIdx++;
         } else if (isSeparator && lineContent[i] === '-') {
+          // Skip per-character conceals that land inside a truncated cell;
+          // the cell-wide truncate conceal already handles the rendering.
+          const inTruncated = truncatedCellCharRanges.some(r => i >= r.start && i < r.end);
+          if (inTruncated) continue;
           const db = charToByte(lineContent, i, byteStart);
           editor.addConceal(bufferId, "md-syntax", db, charToByte(lineContent, i + 1, byteStart), "─");
         }
@@ -1292,7 +1337,7 @@ function processLineSoftBreaks(
 
   const viewport = editor.getViewport();
   if (!viewport) return;
-  const width = config.composeWidth ?? viewport.width;
+  const width = effectiveComposeWidth(viewport.width);
 
   // Parse this single line to get block structure
   const blocks = parseMarkdownBlocks(lineContent);
@@ -1516,9 +1561,12 @@ function processTableAlignment(
       mergeWith(widthMap.get(ln)!.maxW);
     }
 
-    // Compute allocated widths constrained to viewport
+    // Compute allocated widths constrained to viewport. Clamp the
+    // configured compose width to the actual viewport — otherwise a
+    // large configured width overflows when the editor area shrinks
+    // (e.g. when the File Explorer sidebar opens).
     const viewport = editor.getViewport();
-    const composeW = config.composeWidth ?? (viewport ? viewport.width : 80);
+    const composeW = effectiveComposeWidth(viewport ? viewport.width : 80);
     const numCols = merged.length;
     const available = composeW - (numCols + 1); // subtract pipe/box-drawing characters
     const allocated = distributeColumnWidths(merged, available);
@@ -1562,15 +1610,40 @@ function processTableAlignment(
 }
 
 // lines_changed: called for newly visible or invalidated lines
-function onMarkdownLinesChanged(data: {
-  buffer_id: number;
-  lines: Array<{
-    line_number: number;
-    byte_start: number;
-    byte_end: number;
-    content: string;
-  }>;
-}): void {
+
+
+// after_insert: no-op for conceals/overlays.
+// The edit automatically invalidates seen_byte_ranges for affected lines,
+// causing lines_changed to fire on the next render. processLineConceals
+// handles clearing and rebuilding atomically.
+// Marker-based positions auto-adjust with buffer edits, so existing conceals
+// remain visually correct until lines_changed rebuilds them.
+
+
+// after_delete: no-op for conceals/overlays (same reasoning as after_insert).
+
+
+// cursor_moved: update cursor-aware reveal/conceal for old and new cursor lines
+
+
+// view_transform_request is no longer needed — soft wrapping is handled by
+// marker-based soft breaks (computed in lines_changed), and layout hints
+// are set directly via setLayoutHints. This eliminates the one-frame flicker
+// caused by the async view_transform round-trip.
+
+// Handle buffer close events - clean up compose mode tracking
+
+
+// viewport_changed: recalculate table column widths on terminal resize
+
+
+// Re-enable compose mode for buffers restored from a saved session.
+// The Rust side restores ViewMode::Compose and compose_width, but the plugin
+// needs to re-apply line numbers, line wrap, and layout hints when activated.
+
+
+// Register hooks
+editor.on("lines_changed", (data) => {
   if (!isComposingInAnySplit(data.buffer_id)) return;
   const lineNums = data.lines.map(l => `${l.line_number}(${l.byte_start}..${l.byte_end})`).join(', ');
   editor.debug(`[mc] lines_changed: ${data.lines.length} lines: [${lineNums}]`);
@@ -1605,49 +1678,16 @@ function onMarkdownLinesChanged(data: {
   if (tableWidthsGrew) {
     editor.refreshLines(data.buffer_id);
   }
-}
-registerHandler("onMarkdownLinesChanged", onMarkdownLinesChanged);
-
-// after_insert: no-op for conceals/overlays.
-// The edit automatically invalidates seen_byte_ranges for affected lines,
-// causing lines_changed to fire on the next render. processLineConceals
-// handles clearing and rebuilding atomically.
-// Marker-based positions auto-adjust with buffer edits, so existing conceals
-// remain visually correct until lines_changed rebuilds them.
-function onMarkdownAfterInsert(data: {
-  buffer_id: number;
-  position: number;
-  text: string;
-  affected_start: number;
-  affected_end: number;
-}): void {
+});
+editor.on("after_insert", (data) => {
   if (!isComposingInAnySplit(data.buffer_id)) return;
   editor.debug(`[mc] after_insert: pos=${data.position} text="${data.text.replace(/\n/g,'\\n')}" affected=${data.affected_start}..${data.affected_end}`);
-}
-registerHandler("onMarkdownAfterInsert", onMarkdownAfterInsert);
-
-// after_delete: no-op for conceals/overlays (same reasoning as after_insert).
-function onMarkdownAfterDelete(data: {
-  buffer_id: number;
-  start: number;
-  end: number;
-  deleted_text: string;
-  affected_start: number;
-  deleted_len: number;
-}): void {
+});
+editor.on("after_delete", (data) => {
   if (!isComposingInAnySplit(data.buffer_id)) return;
   editor.debug(`[mc] after_delete: start=${data.start} end=${data.end} deleted="${data.deleted_text.replace(/\n/g,'\\n')}" affected_start=${data.affected_start} deleted_len=${data.deleted_len}`);
-}
-registerHandler("onMarkdownAfterDelete", onMarkdownAfterDelete);
-
-// cursor_moved: update cursor-aware reveal/conceal for old and new cursor lines
-function onMarkdownCursorMoved(data: {
-  buffer_id: number;
-  cursor_id: number;
-  old_position: number;
-  new_position: number;
-  line: number;
-}): void {
+});
+editor.on("cursor_moved", (data) => {
   if (!isComposingInAnySplit(data.buffer_id)) return;
 
   const prevLine = editor.getViewState(data.buffer_id, "last-cursor-line") as number | undefined;
@@ -1659,28 +1699,12 @@ function onMarkdownCursorMoved(data: {
   // auto-expose is span-level (cursor entering/leaving an emphasis or link
   // span within the same line must toggle its syntax markers).
   editor.refreshLines(data.buffer_id);
-}
-registerHandler("onMarkdownCursorMoved", onMarkdownCursorMoved);
-
-// view_transform_request is no longer needed — soft wrapping is handled by
-// marker-based soft breaks (computed in lines_changed), and layout hints
-// are set directly via setLayoutHints. This eliminates the one-frame flicker
-// caused by the async view_transform round-trip.
-
-// Handle buffer close events - clean up compose mode tracking
-function onMarkdownBufferClosed(data: { buffer_id: number }) : void {
+});
+// view_transform_request hook no longer needed — wrapping is handled by soft breaks
+editor.on("buffer_closed", (data) => {
   // View state is cleaned up automatically when the buffer is removed from keyed_states
-}
-registerHandler("onMarkdownBufferClosed", onMarkdownBufferClosed);
-
-// viewport_changed: recalculate table column widths on terminal resize
-function onMarkdownViewportChanged(data: {
-  split_id: number;
-  buffer_id: number;
-  top_byte: number;
-  width: number;
-  height: number;
-}): void {
+});
+editor.on("viewport_changed", (data) => {
   if (!isComposingInAnySplit(data.buffer_id)) return;
   if (data.width === lastViewportWidth) return;
   lastViewportWidth = data.width;
@@ -1688,7 +1712,7 @@ function onMarkdownViewportChanged(data: {
   // Recompute allocated table column widths for new viewport width
   const bufWidths = getTableWidths(data.buffer_id);
   if (bufWidths) {
-    const composeW = config.composeWidth ?? data.width;
+    const composeW = effectiveComposeWidth(data.width);
     const seen = new Set<string>(); // Track by JSON key to deduplicate shared TableWidthInfo
     for (const [lineNum, info] of bufWidths) {
       const key = info.maxW.join(",");
@@ -1701,13 +1725,39 @@ function onMarkdownViewportChanged(data: {
     setTableWidths(data.buffer_id, bufWidths);
   }
   editor.refreshLines(data.buffer_id);
-}
-registerHandler("onMarkdownViewportChanged", onMarkdownViewportChanged);
+});
+editor.on("prompt_confirmed", (args) => {
+  if (args.prompt_type !== "markdown-compose-width") return;
 
-// Re-enable compose mode for buffers restored from a saved session.
-// The Rust side restores ViewMode::Compose and compose_width, but the plugin
-// needs to re-apply line numbers, line wrap, and layout hints when activated.
-function onMarkdownBufferActivated(data: { buffer_id: number }) : void {
+  const input = args.input.trim();
+  if (input.toLowerCase() === "none") {
+    config.composeWidth = null;
+    editor.setStatus(editor.t("status.width_none"));
+
+    const bufferId = editor.getActiveBufferId();
+    if (isComposing(bufferId)) {
+      editor.setLayoutHints(bufferId, null, {});
+      editor.refreshLines(bufferId);
+    }
+    return;
+  }
+
+  const width = parseInt(input, 10);
+  if (!isNaN(width) && width > 20 && width < 300) {
+    config.composeWidth = width;
+    editor.setStatus(editor.t("status.width_set", { width: String(width) }));
+
+    // Re-process active buffer if in compose mode
+    const bufferId = editor.getActiveBufferId();
+    if (isComposing(bufferId)) {
+      editor.setLayoutHints(bufferId, null, { composeWidth: config.composeWidth ?? undefined });
+      editor.refreshLines(bufferId);  // Trigger soft break recomputation
+    }
+  } else {
+    editor.setStatus(editor.t("status.invalid_width"));
+  }
+});
+editor.on("buffer_activated", (data) => {
   const bufferId = data.buffer_id;
 
   const info = editor.getBufferInfo(bufferId);
@@ -1726,19 +1776,7 @@ function onMarkdownBufferActivated(data: { buffer_id: number }) : void {
     // markdown buffers that aren't already in compose mode.
     enableMarkdownCompose(bufferId);
   }
-}
-registerHandler("onMarkdownBufferActivated", onMarkdownBufferActivated);
-
-// Register hooks
-editor.on("lines_changed", "onMarkdownLinesChanged");
-editor.on("after_insert", "onMarkdownAfterInsert");
-editor.on("after_delete", "onMarkdownAfterDelete");
-editor.on("cursor_moved", "onMarkdownCursorMoved");
-// view_transform_request hook no longer needed — wrapping is handled by soft breaks
-editor.on("buffer_closed", "onMarkdownBufferClosed");
-editor.on("viewport_changed", "onMarkdownViewportChanged");
-editor.on("prompt_confirmed", "onMarkdownComposeWidthConfirmed");
-editor.on("buffer_activated", "onMarkdownBufferActivated");
+});
 
 // Set compose width command - starts interactive prompt
 function markdownSetComposeWidth() : void {
@@ -1753,41 +1791,7 @@ function markdownSetComposeWidth() : void {
 registerHandler("markdownSetComposeWidth", markdownSetComposeWidth);
 
 // Handle compose width prompt confirmation
-function onMarkdownComposeWidthConfirmed(args: {
-  prompt_type: string;
-  input: string;
-}): void {
-  if (args.prompt_type !== "markdown-compose-width") return;
-
-  const input = args.input.trim();
-  if (input.toLowerCase() === "none") {
-    config.composeWidth = null;
-    editor.setStatus(editor.t("status.width_none"));
-
-    const bufferId = editor.getActiveBufferId();
-    if (isComposing(bufferId)) {
-      editor.setLayoutHints(bufferId, null, {});
-      editor.refreshLines(bufferId);
-    }
-    return;
-  }
 
-  const width = parseInt(input, 10);
-  if (!isNaN(width) && width > 20 && width < 300) {
-    config.composeWidth = width;
-    editor.setStatus(editor.t("status.width_set", { width: String(width) }));
-
-    // Re-process active buffer if in compose mode
-    const bufferId = editor.getActiveBufferId();
-    if (isComposing(bufferId)) {
-      editor.setLayoutHints(bufferId, null, { composeWidth: config.composeWidth ?? undefined });
-      editor.refreshLines(bufferId);  // Trigger soft break recomputation
-    }
-  } else {
-    editor.setStatus(editor.t("status.invalid_width"));
-  }
-}
-registerHandler("onMarkdownComposeWidthConfirmed", onMarkdownComposeWidthConfirmed);
 
 // Register commands
 editor.registerCommand(

package/plugins/markdown_source.ts

@@ -343,17 +343,15 @@ function updateMarkdownMode(): void {
   }
 }
 
-function md_src_on_buffer_activated() : void {
-  updateMarkdownMode();
-}
-registerHandler("md_src_on_buffer_activated", md_src_on_buffer_activated);
 
-function md_src_on_language_changed() : void {
-  updateMarkdownMode();
-}
-registerHandler("md_src_on_language_changed", md_src_on_language_changed);
 
-editor.on("buffer_activated", "md_src_on_buffer_activated");
-editor.on("language_changed", "md_src_on_language_changed");
+
+
+editor.on("buffer_activated", () => {
+  updateMarkdownMode();
+});
+editor.on("language_changed", () => {
+  updateMarkdownMode();
+});
 
 editor.debug("markdown_source plugin loaded");

package/plugins/marksman-lsp.ts

@@ -22,7 +22,8 @@ interface ActionPopupResultData {
 const INSTALL_URL = "https://github.com/artempyanykh/marksman#how-to-install";
 let markdownLspError: { serverCommand: string; message: string } | null = null;
 
-function on_markdown_lsp_server_error(data: LspServerErrorData) : void {
+
+editor.on("lsp_server_error", (data) => {
   if (data.language !== "markdown") return;
   markdownLspError = { serverCommand: data.server_command, message: data.message };
   if (data.error_type === "not_found") {
@@ -30,11 +31,10 @@ function on_markdown_lsp_server_error(data: LspServerErrorData) : void {
   } else {
     editor.setStatus(`Markdown LSP error: ${data.message}`);
   }
-}
-registerHandler("on_markdown_lsp_server_error", on_markdown_lsp_server_error);
-editor.on("lsp_server_error", "on_markdown_lsp_server_error");
+});
+
 
-function on_markdown_lsp_status_clicked(data: LspStatusClickedData) : void {
+editor.on("lsp_status_clicked", (data) => {
   if (data.language !== "markdown" || !markdownLspError) return;
   editor.showActionPopup({
     id: "marksman-lsp-help",
@@ -46,11 +46,10 @@ function on_markdown_lsp_status_clicked(data: LspStatusClickedData) : void {
       { id: "dismiss", label: "Dismiss (ESC)" },
     ],
   });
-}
-registerHandler("on_markdown_lsp_status_clicked", on_markdown_lsp_status_clicked);
-editor.on("lsp_status_clicked", "on_markdown_lsp_status_clicked");
+});
+
 
-function on_markdown_lsp_action_result(data: ActionPopupResultData) : void {
+editor.on("action_popup_result", (data) => {
   if (data.popup_id !== "marksman-lsp-help") return;
   switch (data.action_id) {
     case "copy_url":
@@ -63,6 +62,4 @@ function on_markdown_lsp_action_result(data: ActionPopupResultData) : void {
       markdownLspError = null;
       break;
   }
-}
-registerHandler("on_markdown_lsp_action_result", on_markdown_lsp_action_result);
-editor.on("action_popup_result", "on_markdown_lsp_action_result");
+});

package/plugins/merge_conflict.ts

@@ -1700,7 +1700,18 @@ registerHandler("merge_show_help", merge_show_help);
 /**
  * Handle buffer activation - check for conflict markers
  */
-async function onMergeBufferActivated(data: { buffer_id: number }) : Promise<void> {
+
+
+/**
+ * Handle file open - check for conflict markers
+ */
+
+
+// =============================================================================
+// Hook Registration
+// =============================================================================
+
+editor.on("buffer_activated", async (data) => {
   // Don't trigger if already in merge mode
   if (mergeState.isActive) return;
 
@@ -1724,13 +1735,8 @@ async function onMergeBufferActivated(data: { buffer_id: number }) : Promise<voi
   } catch (e) {
     // Not in git repo or other error, ignore
   }
-}
-registerHandler("onMergeBufferActivated", onMergeBufferActivated);
-
-/**
- * Handle file open - check for conflict markers
- */
-async function onMergeAfterFileOpen(data: { buffer_id: number; path: string }) : Promise<void> {
+});
+editor.on("after_file_open", async (data) => {
   // Don't trigger if already in merge mode
   if (mergeState.isActive) return;
 
@@ -1750,15 +1756,7 @@ async function onMergeAfterFileOpen(data: { buffer_id: number; path: string }) :
   } catch (e) {
     // Not in git repo or other error, ignore
   }
-}
-registerHandler("onMergeAfterFileOpen", onMergeAfterFileOpen);
-
-// =============================================================================
-// Hook Registration
-// =============================================================================
-
-editor.on("buffer_activated", "onMergeBufferActivated");
-editor.on("after_file_open", "onMergeAfterFileOpen");
+});
 
 // =============================================================================
 // Command Registration - Dynamic based on merge mode state

package/plugins/nim-lsp.ts

@@ -35,7 +35,8 @@ const INSTALL_COMMANDS = {
 
 let nimLspError: { serverCommand: string; message: string } | null = null;
 
-function on_nim_lsp_server_error(data: LspServerErrorData): void {
+
+editor.on("lsp_server_error", (data) => {
   if (data.language !== "nim") {
     return;
   }
@@ -54,11 +55,10 @@ function on_nim_lsp_server_error(data: LspServerErrorData): void {
   } else {
     editor.setStatus(`Nim LSP error: ${data.message}`);
   }
-}
-registerHandler("on_nim_lsp_server_error", on_nim_lsp_server_error);
-editor.on("lsp_server_error", "on_nim_lsp_server_error");
+});
+
 
-function on_nim_lsp_status_clicked(data: LspStatusClickedData): void {
+editor.on("lsp_status_clicked", (data) => {
   if (data.language !== "nim" || !nimLspError) {
     return;
   }
@@ -76,11 +76,10 @@ function on_nim_lsp_status_clicked(data: LspStatusClickedData): void {
       { id: "dismiss", label: "Dismiss (ESC)" },
     ],
   });
-}
-registerHandler("on_nim_lsp_status_clicked", on_nim_lsp_status_clicked);
-editor.on("lsp_status_clicked", "on_nim_lsp_status_clicked");
+});
+
 
-function on_nim_lsp_action_result(data: ActionPopupResultData): void {
+editor.on("action_popup_result", (data) => {
   if (data.popup_id !== "nim-lsp-help") {
     return;
   }
@@ -111,8 +110,6 @@ function on_nim_lsp_action_result(data: ActionPopupResultData): void {
     default:
       editor.debug(`nim-lsp: Unknown action: ${data.action_id}`);
   }
-}
-registerHandler("on_nim_lsp_action_result", on_nim_lsp_action_result);
-editor.on("action_popup_result", "on_nim_lsp_action_result");
+});
 
 editor.debug("nim-lsp: Plugin loaded");

package/plugins/nix-lsp.ts

@@ -36,7 +36,8 @@ const INSTALL_COMMANDS = {
 
 let nixLspError: { serverCommand: string; message: string } | null = null;
 
-function on_nix_lsp_server_error(data: LspServerErrorData): void {
+
+editor.on("lsp_server_error", (data) => {
   if (data.language !== "nix") {
     return;
   }
@@ -55,11 +56,10 @@ function on_nix_lsp_server_error(data: LspServerErrorData): void {
   } else {
     editor.setStatus(`Nix LSP error: ${data.message}`);
   }
-}
-registerHandler("on_nix_lsp_server_error", on_nix_lsp_server_error);
-editor.on("lsp_server_error", "on_nix_lsp_server_error");
+});
+
 
-function on_nix_lsp_status_clicked(data: LspStatusClickedData): void {
+editor.on("lsp_status_clicked", (data) => {
   if (data.language !== "nix" || !nixLspError) {
     return;
   }
@@ -78,11 +78,10 @@ function on_nix_lsp_status_clicked(data: LspStatusClickedData): void {
       { id: "dismiss", label: "Dismiss (ESC)" },
     ],
   });
-}
-registerHandler("on_nix_lsp_status_clicked", on_nix_lsp_status_clicked);
-editor.on("lsp_status_clicked", "on_nix_lsp_status_clicked");
+});
+
 
-function on_nix_lsp_action_result(data: ActionPopupResultData): void {
+editor.on("action_popup_result", (data) => {
   if (data.popup_id !== "nix-lsp-help") {
     return;
   }
@@ -118,8 +117,6 @@ function on_nix_lsp_action_result(data: ActionPopupResultData): void {
     default:
       editor.debug(`nix-lsp: Unknown action: ${data.action_id}`);
   }
-}
-registerHandler("on_nix_lsp_action_result", on_nix_lsp_action_result);
-editor.on("action_popup_result", "on_nix_lsp_action_result");
+});
 
 editor.debug("nix-lsp: Plugin loaded");