@fresh-editor/fresh-editor 0.3.9 → 0.3.10

package/plugins/lib/finder.ts

@@ -116,9 +116,37 @@ export interface FinderConfig<T> {
   /** Panel-specific: navigate source split when cursor moves (preview without focus change) */
   navigateOnCursorMove?: boolean;
 
+  /**
+   * Panel-specific: whether selecting an entry (Enter) closes the
+   * panel. Defaults to `true` — the panel dismisses as it jumps, which
+   * suits one-shot lists like Find References. Set `false` to keep the
+   * panel docked so the user can step through entries (Vim quickfix /
+   * VS Code results list). Only consulted by the default selection
+   * handler — a custom `onSelect` owns close behaviour itself.
+   *
+   * Note: leaving the panel open while `navigateOnCursorMove` is also
+   * on re-introduces the focus race the close was guarding against
+   * (a `focusSplit` queued after the jump can re-grab the panel), so
+   * the two shouldn't be combined without care.
+   */
+  closeOnSelect?: boolean;
+
   /** Called when the panel or prompt is closed (e.g. via Escape) */
   onClose?: () => void;
 
+  /**
+   * Panel-specific: extra key bindings active while the panel buffer
+   * is focused, as `[key, command]` pairs (e.g. `["q", "my_close"]`).
+   * `command` is dispatched as a plugin action, so it should name a
+   * handler registered via `registerHandler`. These augment the
+   * built-in `Return` (select) and `Escape` (close) bindings.
+   *
+   * Without this, keys a plugin advertises in its panel UI (e.g.
+   * "q: close") fall through to the read-only text layer and trip
+   * "Editing disabled in this buffer" (issue #2125).
+   */
+  panelKeys?: Array<[string, string]>;
+
   /**
    * When true, panels created by this Finder are routed into the
    * shared Utility Dock (issue #1796 / Section 2 of
@@ -1111,12 +1139,17 @@ export class Finder<T> {
   private registerPanelHandlers(): void {
     const self = this;
 
-    // Define panel mode
+    // Define panel mode. The built-in Return/Escape bindings are
+    // augmented with any caller-supplied `panelKeys` so plugin-specific
+    // shortcuts (e.g. Diagnostics' "q: close | a: toggle filter") resolve
+    // to their handlers instead of falling through to the read-only text
+    // layer (issue #2125).
     this.editor.defineMode(
       this.modeName,
       [
         ["Return", `${this.handlerPrefix}_panel_select`],
         ["Escape", `${this.handlerPrefix}_panel_close`],
+        ...(this.config.panelKeys ?? []),
       ],
       true
     );
@@ -1398,13 +1431,17 @@ export class Finder<T> {
     } else if (entry.location) {
       const loc = entry.location;
 
-      // Close the panel first. This is necessary because
-      // navigateOnCursorMove's focusSplit(panelSplitId) can interfere with
-      // the jump — it queues a FocusSplit that runs after OpenFileInSplit
-      // and restores the panel as the active split.
-      this.closePanel();
+      // Close the panel first (unless the consumer opted to keep it
+      // docked via `closeOnSelect: false`). Closing is the default
+      // because navigateOnCursorMove's focusSplit(panelSplitId) can
+      // interfere with the jump — it queues a FocusSplit that runs after
+      // OpenFileInSplit and restores the panel as the active split.
+      if (this.config.closeOnSelect !== false) {
+        this.closePanel();
+      }
 
-      // Now navigate with the panel gone — only one split remains
+      // openFile routes away from the dock leaf, so with the panel kept
+      // open the file lands in the editor pane and the list stays put.
       this.editor.openFile(loc.file, loc.line, loc.column);
       this.editor.setStatus(`Jumped to ${loc.file}:${loc.line}`);
     }

package/plugins/lib/fresh.d.ts

@@ -736,7 +736,7 @@ type CursorInfo = {
 		end: number;
 	} | null;
 	/**
-	* 0-indexed line number of the cursor. `None` when the line index is
+	* 0-indexed line number of the cursor. `null` when the line index is
 	* unavailable — e.g. a huge file whose line scan hasn't completed, where
 	* the editor positions purely by byte offset. Plugins must treat `null`
 	* as "unknown", never as line 0.
@@ -903,6 +903,15 @@ type WidgetSpec = {
 	"kind": "row";
 	children: Array<WidgetSpec>;
 	key?: string | null;
+	/**
+	* When true, children that don't fit on one line reflow onto
+	* additional lines (growing the row's height) instead of being
+	* truncated. Children are never split — wrap happens at child
+	* boundaries — so wrap a logical group (e.g. a toggle + its
+	* accelerator) in a nested non-wrapping `Row` to keep it intact.
+	* Ignored when the row contains multi-line (block) children.
+	*/
+	wrap: boolean;
 } | {
 	"kind": "col";
 	children: Array<WidgetSpec>;
@@ -1213,6 +1222,16 @@ interface SearchHandle {
 	take(): SearchTakeResult;
 	cancel(): void;
 }
+type ReplaceResult = {
+	/**
+	* Number of replacements made
+	*/
+	replacements: number;
+	/**
+	* Buffer ID of the edited buffer
+	*/
+	bufferId: number;
+};
 type AuthorityFilesystem = {
 	kind: "local";
 };
@@ -1496,16 +1515,6 @@ type RemoteIndicatorStatePayload = {
 	kind: "disconnected";
 	label?: string | null;
 };
-type ReplaceResult = {
-	/**
-	* Number of replacements made
-	*/
-	replacements: number;
-	/**
-	* Buffer ID of the edited buffer
-	*/
-	bufferId: number;
-};
 type SpawnResult = {
 	/**
 	* Complete stdout as string
@@ -1629,6 +1638,13 @@ interface EditorAPI {
 	*/
 	executeAction(actionName: string): boolean;
 	/**
+	* Cancel the active prompt / overlay — the same teardown the
+	* Escape key triggers. Lets a plugin dismiss a prompt it opened
+	* (e.g. exporting Live Grep results to a dock panel) without
+	* routing a synthetic keypress.
+	*/
+	cancelPrompt(): boolean;
+	/**
 	* Register a custom statusbar token.
 	* Token will be named "plugin_name:token_name" where plugin_name is the current plugin.
 	* Returns true if registration succeeded, false if invalid or already registered.
@@ -2126,21 +2142,21 @@ interface EditorAPI {
 	*/
 	getDataDir(): string;
 	/**
-	* Per-working-directory data root for plugin state that should be scoped
-	* to the current project root / worktree rather than shared across all of
-	* them (`<data_dir>/workdirs/<encoded-cwd>/`). Prefer this over
-	* `getDataDir()` for per-project state; the directory is not created for
-	* you. Note: terminal scrollback and orchestrator state use their own
-	* dedicated layouts (see `getTerminalDir()`), not this root.
-	*/
-	getWorkingDataDir(): string;
-	/**
 	* Directory holding terminal scrollback backing files for the current
 	* working directory. Each project root / worktree has its own subdir, so
-	* a search can stay scoped to the active project's terminals.
+	* Universal Search's terminal scope can stay scoped to the active
+	* project rather than spanning every project's terminals.
 	*/
 	getTerminalDir(): string;
 	/**
+	* Per-working-directory data root for plugin state scoped to the current
+	* project root / worktree (`<data_dir>/workdirs/<encoded-cwd>/`). Use
+	* instead of `getDataDir()` for state that should not be shared across
+	* worktrees. The directory is not created here — callers create what
+	* they need under it.
+	*/
+	getWorkingDataDir(): string;
+	/**
 	* Get themes directory path
 	*/
 	getThemesDir(): string;
@@ -2274,6 +2290,12 @@ interface EditorAPI {
 	*/
 	clearOverlaysInRange(bufferId: number, start: number, end: number): boolean;
 	/**
+	* Clear overlays in a single namespace that overlap with a byte range.
+	* Unlike clearOverlaysInRange, overlays in other namespaces (e.g.
+	* editor-owned LSP diagnostics) are left untouched.
+	*/
+	clearOverlaysInRangeForNamespace(bufferId: number, namespace: string, start: number, end: number): boolean;
+	/**
 	* Remove an overlay by its handle
 	*/
 	removeOverlay(bufferId: number, handle: string): boolean;
@@ -2479,26 +2501,21 @@ interface EditorAPI {
 	*/
 	setPromptFooter(footer: StyledText[]): boolean;
 	/**
-	* Set the floating-overlay prompt's header toolbar as a `WidgetSpec`
-	* (real, clickable `Toggle`/`Button` widgets), rendered in place of the
-	* styled-text title. Give each control a `key` equal to the action it
-	* should fire on click (e.g. `"live_grep_toggle_files"`). Pass `null` to
-	* clear it. No visible effect on non-overlay prompts.
+	* Set the floating-overlay prompt's input-row status text (right-aligned,
+	* left of the match count). Empty string clears it.
 	*/
-	setPromptToolbar(spec: WidgetSpec | null): boolean;
+	setPromptStatus(status: string): boolean;
 	/**
-	* Set the floating-overlay prompt's input-row status text, shown
-	* right-aligned just left of the `selected / total` count (e.g.
-	* "Searching…", "No matches"). Empty string clears it. No effect on
-	* non-overlay prompts.
+	* Set the floating-overlay prompt's toolbar as a `WidgetSpec` (real,
+	* clickable `Toggle`/`Button` widgets rendered in the header band, in
+	* place of the styled-text title). Pass `null`/`undefined` to clear it.
 	*/
-	setPromptStatus(status: string): boolean;
+	setPromptToolbar(specObj: unknown): boolean;
 	/**
 	* Toggle a floating-overlay toolbar control by its widget `key`. The host
-	* owns the toggle's checked state, flips it in place, and emits a
-	* `widget_event` (`event_type: "toggle"`, payload `{ checked }`). Use this
-	* to route a plugin's own keyboard shortcut through the same host path as
-	* a click or Space on the toggle, then react in your `widget_event` handler.
+	* owns the toggle's checked state, flips it, and emits a `widget_event`
+	* the plugin can listen for. Lets a plugin route its own Alt+… shortcut
+	* through the same host path as a click / Space on the toggle.
 	*/
 	toggleOverlayToolbarWidget(key: string): boolean;
 	/**
@@ -2966,13 +2983,14 @@ interface EditorAPI {
 		caseSensitive?: boolean;
 		maxResults?: number;
 		wholeWords?: boolean;
+		sourceBufferId?: number;
 	}): SearchHandle;
 	/**
 	* Replace matches in a file's buffer (async)
 	* Opens the file if not already in a buffer, applies edits via the buffer model,
 	* and saves. All edits are grouped as a single undo action.
 	*/
-	replaceInFile(filePath: string, matches: number[][], replacement: string): Promise<ReplaceResult>;
+	replaceInFile(filePath: string, matches: number[][], replacement: string, bufferId?: number): Promise<ReplaceResult>;
 	/**
 	* Send LSP request (async, returns request_id)
 	*/

package/plugins/live_diff.ts

@@ -978,7 +978,18 @@ async function recompute(bufferId: number): Promise<void> {
     }
 
     const length = editor.getBufferLength(bufferId);
-    const newText = await editor.getBufferText(bufferId, 0, length);
+    let newText: string;
+    try {
+      newText = await editor.getBufferText(bufferId, 0, length);
+    } catch (e) {
+      // The buffer can close between the awaits above (the git `show`
+      // for the reference is slow) and this fetch — e.g. the user
+      // closes the file, or an external process churns it while it's
+      // open. `buffer_closed` deletes our state, so if it's gone the
+      // recompute is moot: bail quietly instead of logging an error.
+      if (!states.has(bufferId)) return;
+      throw e;
+    }
 
     // Skip 1: same buffer text as last recompute. `lines_changed` fires
     // on viewport scrolls (cursor up/down past the visible area), and

package/plugins/live_grep.ts

@@ -179,6 +179,11 @@ let overlayActive = false;
 // pre-filled (rather than a bespoke cached-results overlay).
 let lastQuery = "";
 
+// The most recent merged result set, captured by `search` so the
+// Quickfix export can snapshot exactly what the user is looking at into
+// the dock panel without re-running the search.
+let lastResults: GrepMatch[] = [];
+
 // ── Search modes ──────────────────────────────────────────────────
 //
 // Separate from *where* we search (scopes): these control *how* the
@@ -314,7 +319,7 @@ function buildToolbarSpec(provider: LiveGrepProvider | null): WidgetSpec {
   // an atomic group of `toggle + accelerator` — so the wrapping parent never
   // splits a label from its `Alt+…` hint across lines.
   const prefix = (text: string): WidgetSpec =>
-    raw([styledRow([{ text, style: { fg: "ui.popup_border_fg" } }])]);
+    raw([styledRow([{ text, style: { fg: "ui.suggestion_fg" } }])]);
 
   const sources: WidgetSpec[] = [spacer(1), prefix(editor.t("label.search_in"))];
   SCOPES.forEach((s) => {
@@ -355,13 +360,14 @@ function buildToolbarSpec(provider: LiveGrepProvider | null): WidgetSpec {
 function buildMetaRow(provider: LiveGrepProvider | null): WidgetSpec | null {
   const hintStyle = { fg: "ui.help_key_fg" };
   const sepStyle = { fg: "ui.popup_border_fg" };
+  const labelStyle = { fg: "ui.suggestion_fg" };
   const parts: WidgetSpec[] = [];
 
   // Provider button — only when a file-backed scope is on (irrelevant when
   // searching only buffers/terminals/diagnostics). The button is keyed
   // "provider"; activating it (click / Space / Alt+P) cycles the backend.
   if (provider && (scopeEnabled.files || scopeEnabled.ignored)) {
-    parts.push(raw([styledRow([{ text: "Provider: ", style: sepStyle }])]));
+    parts.push(raw([styledRow([{ text: "Provider: ", style: labelStyle }])]));
     parts.push(button(provider.name, { key: "provider" }));
     const pAccel = editor.getKeybindingLabel("cycle_live_grep_provider", "prompt");
     if (pAccel) {
@@ -661,6 +667,63 @@ const finder = new Finder<GrepMatch>(editor, {
   maxResults: MAX_RESULTS,
 });
 
+// The Quickfix list is just another "list of locations" surface, so it
+// rides the same Finder panel abstraction as Diagnostics and Find
+// References (dockable via `useUtilityDock`, Enter → openFile for free).
+// Exporting hands it a static snapshot of the current matches; the
+// bespoke Rust quickfix buffer it replaced is gone.
+const quickfixFinder = new Finder<GrepMatch>(editor, {
+  id: "quickfix",
+  format: (match) => ({
+    label: `${match.file}:${match.line}:${match.column}`,
+    description: match.content.trim(),
+    location: {
+      file: match.file,
+      line: match.line,
+      column: match.column,
+    },
+  }),
+  useUtilityDock: true,
+  // Keep the Quickfix list docked when jumping to an entry — like Vim's
+  // quickfix and VS Code's results list — so the user can step through
+  // matches. (Find References / Diagnostics keep the default close.)
+  closeOnSelect: false,
+});
+
+// Snapshot the current Live Grep results into the Quickfix dock panel.
+// Bound to the `live_grep_export_quickfix` keybinding (Alt+M / Alt+Q,
+// when=prompt) — a plain plugin action now that the Rust action is gone.
+function exportQuickfix(): void {
+  if (!overlayActive) return;
+  if (lastResults.length === 0) {
+    editor.setStatus("No Live Grep results to export");
+    return;
+  }
+  const query = lastQuery;
+  const matches = lastResults;
+  // Dismiss the host overlay first so the panel opens against the editor
+  // pane (which is then routed into the dock), not behind the overlay.
+  // `cancelPrompt` is the same teardown Escape triggers; the plugin's
+  // own prompt state is cleared via the resulting `prompt_cancelled`
+  // hook.
+  editor.cancelPrompt();
+  void quickfixFinder.panel({
+    title: `Quickfix: ${query} (${matches.length} matches)`,
+    items: matches,
+  });
+}
+registerHandler("live_grep_export_quickfix", exportQuickfix);
+// Register the action→handler mapping so the `live_grep_export_quickfix`
+// keybinding (a PluginAction now) resolves across the plugin boundary.
+// A never-activated context keeps it out of the palette — it's only
+// meaningful from inside the Live Grep overlay.
+editor.registerCommand(
+  "Live Grep: Export to Quickfix (internal)",
+  "",
+  "live_grep_export_quickfix",
+  "live-grep-internal"
+);
+
 /**
  * Switch to the next *available* registered provider, in priority
  * order, wrapping at the end. Unavailable providers (those whose
@@ -936,6 +999,7 @@ async function search(query: string): Promise<GrepMatch[]> {
   if (lastSearchTruncated !== wasTruncated) {
     updateOverlayTitle(cachedSelected ?? null);
   }
+  lastResults = results;
   return results;
 }
 

package/plugins/markdown_compose.ts

@@ -1046,7 +1046,9 @@ function processLineConceals(
   // the one-frame glitch where conceals are cleared but not yet rebuilt.
   editor.debug(`[mc] processLine clear+rebuild bytes=${byteStart}..${byteEnd} content="${lineContent.slice(0,40)}"`);
   editor.clearConcealsInRange(bufferId, byteStart, byteEnd);
-  editor.clearOverlaysInRange(bufferId, byteStart, byteEnd);
+  // Only clear our own emphasis overlays — clearing ALL overlays in the range
+  // would also wipe editor-owned overlays like LSP diagnostics (issue #2146).
+  editor.clearOverlaysInRangeForNamespace(bufferId, "md-emphasis", byteStart, byteEnd);
 
   const cursorOnLine = cursors.some(c => c >= byteStart && c <= byteEnd);
   // Strict version: excludes the boundary at byteEnd so that the cursor