refactor(presets): replace xdg-open with vim.ui.open

Problem: all presets hardcoded `open = { 'xdg-open' }`, making them
Linux-only. The compiler already handles `open = true` via
`vim.ui.open()`, which is cross-platform.

Solution: change all four presets to `open = true`.

.luarc.json

@@ -4,6 +4,5 @@
   "diagnostics.globals": ["vim", "jit"],
   "workspace.library": ["$VIMRUNTIME/lua", "${3rd}/luv/library"],
   "workspace.checkThirdParty": false,
-  "workspace.ignoreDir": [".direnv"],
   "completion.callSnippet": "Replace"
 }

.styluaignore

@@ -1 +0,0 @@
-.direnv/

README.md

@@ -1,38 +1,28 @@
 # preview.nvim
 
-**Universal document previewer for Neovim**
+**Async document compilation for Neovim**
 
-An extensible framework for compiling and previewing _any_ documents (LaTeX,
+An extensible framework for compiling documents (LaTeX, Typst, Markdown, etc.)
-Typst, Markdown, etc.)—diagnostics included.
+asynchronously with error diagnostics.
-
-<video src="https://github.com/user-attachments/assets/3b4fbc31-c1c4-4429-a9dc-a68d6185ab2e" width="100%" controls></video>
 
 ## Features
 
 - Async compilation via `vim.system()`
-- Built-in presets for Typst, LaTeX (latexmk, pdflatex, tectonic), Markdown,
+- Compiler errors as native `vim.diagnostic`
-  GitHub-flavored Markdown, AsciiDoc, PlantUML, Mermaid, and Quarto
+- User events for extensibility (`PreviewCompileStarted`,
-- Compiler errors via `vim.diagnostic` or quickfix
+  `PreviewCompileSuccess`, `PreviewCompileFailed`)
-- Previewer auto-close on buffer deletion
+- Built-in presets for Typst, LaTeX, Markdown, and GitHub-flavored Markdown
+- `:checkhealth` integration
+- Zero dependencies beyond Neovim 0.11.0+
 
 ## Requirements
 
-- Neovim 0.11+
+- Neovim 0.11.0+
 
 ## Installation
 
-With lazy.nvim:
+Install with your package manager of choice or via
-
+[luarocks](https://luarocks.org/modules/barrettruth/preview.nvim):
-```lua
-{
-  'barrettruth/preview.nvim',
-  init = function()
-    vim.g.preview = { typst = true, latex = true }
-  end,
-}
-```
-
-Or via [luarocks](https://luarocks.org/modules/barrettruth/preview.nvim):
 
 ```
 luarocks install preview.nvim
@@ -49,35 +39,35 @@ luarocks install preview.nvim
 **Q: How do I define a custom provider?**
 
 ```lua
-vim.g.preview = {
+require('preview').setup({
-  rst = {
+  typst = {
-    cmd = { 'rst2html' },
+    cmd = { 'typst', 'compile' },
     args = function(ctx)
-      return { ctx.file, ctx.output }
+      return { ctx.file }
     end,
     output = function(ctx)
-      return ctx.file:gsub('%.rst$', '.html')
+      return ctx.file:gsub('%.typ$', '.pdf')
     end,
   },
-}
+})
 ```
 
 **Q: How do I override a preset?**
 
 ```lua
-vim.g.preview = {
+require('preview').setup({
   typst = { env = { TYPST_FONT_PATHS = '/usr/share/fonts' } },
-}
+})
 ```
 
 **Q: How do I automatically open the output file?**
 
 Set `open = true` on your provider (all built-in presets have this enabled) to
-open the output with `vim.ui.open()` after the first successful compilation in
+open the output with `vim.ui.open()` after the first successful compilation. For
-toggle/watch mode. For a specific application, pass a command table:
+a specific application, pass a command table:
 
 ```lua
-vim.g.preview = {
+require('preview').setup({
   typst = { open = { 'sioyek', '--new-instance' } },
-}
+})
 ```

doc/preview.nvim.txt

@@ -0,0 +1,228 @@
+*preview.nvim.txt*                    Async document compilation for Neovim
+
+Author:  Barrett Ruth <br.barrettruth@gmail.com>
+License: MIT
+
+==============================================================================
+INTRODUCTION                                                    *preview.nvim*
+
+preview.nvim is an extensible framework for compiling documents asynchronously
+in Neovim. It provides a unified interface for any compilation workflow —
+LaTeX, Typst, Markdown, or anything else with a CLI compiler.
+
+The plugin ships with zero provider defaults. Users must explicitly configure
+their compiler commands. preview.nvim is purely an orchestration framework.
+
+==============================================================================
+REQUIREMENTS                                          *preview.nvim-requirements*
+
+- Neovim >= 0.11.0
+- A compiler binary for each configured provider (e.g. `typst`, `latexmk`)
+
+==============================================================================
+SETUP                                                  *preview.nvim-setup*
+
+Load preview.nvim with your package manager. For example, with lazy.nvim: >lua
+    {
+      'barrettruth/preview.nvim',
+    }
+<
+Call |preview.setup()| to configure providers before use.
+
+==============================================================================
+CONFIGURATION                                      *preview.nvim-configuration*
+
+Configure via `require('preview').setup()`.
+
+                                                            *preview.setup()*
+setup({opts?})
+
+  `opts` is a table where keys are preset names or filetypes. For each
+  key `k` with value `v` (excluding `debug`):
+
+  - If `k` is a preset name and `v` is `true`, the preset is registered
+    as-is under its filetype.
+  - If `k` is a preset name and `v` is a table, it is deep-merged with
+    the preset and registered under the preset's filetype.
+  - If `k` is not a preset name and `v` is a table, it is registered
+    directly as a custom provider keyed by filetype `k`.
+  - If `v` is `false`, the entry is skipped (no-op).
+
+  See |preview.nvim-presets| for available preset names.
+
+  Fields:~
+
+  `debug`            boolean|string   Enable debug logging. A string value
+                                    is treated as a log file path.
+                                    Default: `false`
+
+                                                    *preview.ProviderConfig*
+Provider fields:~
+
+  `cmd`              string[]         The compiler command (required).
+
+  `args`             string[]|function  Additional arguments. If a function,
+                                      receives a |preview.Context| and returns
+                                      a string[].
+
+  `cwd`              string|function   Working directory. If a function,
+                                      receives a |preview.Context|. Default:
+                                      git root or file directory.
+
+  `env`              table             Environment variables.
+
+  `output`           string|function   Output file path. If a function,
+                                      receives a |preview.Context|.
+
+  `error_parser`     function          Receives (stderr, |preview.Context|)
+                                      and returns vim.Diagnostic[].
+
+  `clean`            string[]|function  Command to remove build artifacts.
+                                       If a function, receives a
+                                       |preview.Context|.
+
+  `open`             boolean|string[]   Open the output file after the first
+                                       successful compilation. `true` uses
+                                       |vim.ui.open()|. A string[] is run as
+                                       a command with the output path appended.
+                                       Presets default to `{ 'xdg-open' }`.
+
+                                                        *preview.Context*
+Context fields:~
+
+  `bufnr`   integer    Buffer number.
+  `file`    string     Absolute file path.
+  `root`    string     Project root (git root or file directory).
+  `ft`      string     Filetype.
+
+Example enabling presets:~
+>lua
+    require('preview').setup({ typst = true, latex = true, github = true })
+<
+
+Example overriding a preset field:~
+>lua
+    require('preview').setup({
+      typst = { open = { 'sioyek', '--new-instance' } },
+    })
+<
+
+Example with a fully custom provider (key is not a preset name):~
+>lua
+    require('preview').setup({
+      rst = {
+        cmd = { 'rst2html' },
+        args = function(ctx)
+          return { ctx.file }
+        end,
+        output = function(ctx)
+          return ctx.file:gsub('%.rst$', '.html')
+        end,
+      },
+    })
+<
+
+==============================================================================
+PRESETS                                                *preview.nvim-presets*
+
+preview.nvim ships with pre-built provider configurations for common tools.
+Import them from `preview.presets`:
+
+  `presets.typst`              typst compile → PDF
+  `presets.latex`              latexmk -pdf → PDF (with clean support)
+  `presets.markdown`           pandoc → HTML (standalone, embedded)
+  `presets.github`             pandoc → HTML (GitHub-styled, `-f gfm` input)
+
+Enable presets with `preset_name = true`:
+>lua
+    require('preview').setup({ typst = true, latex = true, github = true })
+<
+
+Override individual fields by passing a table instead of `true`:
+>lua
+    require('preview').setup({
+      typst = { env = { TYPST_FONT_PATHS = '/usr/share/fonts' } },
+    })
+<
+
+==============================================================================
+COMMANDS                                              *preview.nvim-commands*
+
+:Preview [subcommand]                                             *:Preview*
+
+    Subcommands:~
+
+    `compile`    Compile the current buffer (default if omitted).
+    `stop`       Kill active compilation for the current buffer.
+    `clean`      Run the provider's clean command.
+    `toggle`     Toggle auto-compile on save for the current buffer.
+    `status`     Echo compilation status (idle, compiling, toggled).
+
+==============================================================================
+API                                                        *preview.nvim-api*
+
+preview.compile({bufnr?})                                *preview.compile()*
+    Compile the document in the given buffer (default: current).
+
+preview.stop({bufnr?})                                      *preview.stop()*
+    Kill the active compilation process for the buffer.
+
+preview.clean({bufnr?})                                    *preview.clean()*
+    Run the provider's clean command for the buffer.
+
+preview.toggle({bufnr?})                                  *preview.toggle()*
+    Toggle auto-compile for the buffer. When enabled, the buffer is
+    immediately compiled and automatically recompiled on each save
+    (`BufWritePost`). Call again to stop.
+
+preview.status({bufnr?})                                  *preview.status()*
+    Returns a |preview.Status| table.
+
+                                                          *preview.Status*
+Status fields:~
+
+  `compiling`    boolean    Whether compilation is active.
+  `watching`     boolean    Whether auto-compile is active.
+  `provider`     string?    Name of the active provider.
+  `output_file`  string?    Path to the output file.
+
+preview.get_config()                                  *preview.get_config()*
+    Returns the resolved |preview.Config|.
+
+==============================================================================
+EVENTS                                                  *preview.nvim-events*
+
+preview.nvim fires User autocmds with structured data:
+
+`PreviewCompileStarted`  Compilation began.
+                        data: `{ bufnr, provider }`
+
+`PreviewCompileSuccess`  Compilation succeeded (exit code 0).
+                        data: `{ bufnr, provider, output }`
+
+`PreviewCompileFailed`   Compilation failed (non-zero exit).
+                        data: `{ bufnr, provider, code, stderr }`
+
+Example:~
+>lua
+    vim.api.nvim_create_autocmd('User', {
+      pattern = 'PreviewCompileSuccess',
+      callback = function(args)
+        local data = args.data
+        vim.notify('Compiled ' .. data.output .. ' with ' .. data.provider)
+      end,
+    })
+<
+
+==============================================================================
+HEALTH                                                  *preview.nvim-health*
+
+Run `:checkhealth preview` to verify:
+
+- Neovim version >= 0.11.0
+- Each configured provider's binary is executable
+- Each configured provider's opener binary (if any) is executable
+- Each configured provider's filetype mapping is valid
+
+==============================================================================
+ vim:tw=78:ts=8:ft=help:norl:

doc/preview.txt

@@ -1,276 +0,0 @@
-*preview.txt*                    Async document compilation for Neovim
-
-Author:  Barrett Ruth <br.barrettruth@gmail.com>
-License: MIT
-
-==============================================================================
-INTRODUCTION                                                    *preview.nvim*
-
-preview.nvim is an extensible framework for compiling documents asynchronously
-in Neovim. It provides a unified interface for any compilation workflow —
-LaTeX, Typst, Markdown, or anything else with a CLI compiler.
-
-The plugin ships with opt-in presets for common tools (Typst, LaTeX, Pandoc,
-AsciiDoc, PlantUML, Mermaid, Quarto) and supports fully custom providers.
-See |preview-presets|.
-
-==============================================================================
-CONTENTS                                                   *preview-contents*
-
-  1. Introduction ............................................. |preview.nvim|
-  2. Requirements ..................................... |preview-requirements|
-  3. Install ............................................... |preview-install|
-  4. Configuration ........................................... |preview-config|
-  5. Presets ............................................... |preview-presets|
-  6. Commands ............................................. |preview-commands|
-  7. Lua API ................................................... |preview-api|
-  8. Events ............................................... |preview-events|
-  9. Health ............................................... |preview-health|
-
-==============================================================================
-REQUIREMENTS                                           *preview-requirements*
-
-- Neovim >= 0.11.0
-- A compiler binary for each configured provider (e.g. `typst`, `latexmk`)
-
-==============================================================================
-INSTALL                                                      *preview-install*
-
-Install with lazy.nvim: >lua
-    { 'barrettruth/preview.nvim' }
-<
-
-No `setup()` call is needed. The plugin loads automatically when
-|vim.g.preview| is set. See |preview-config|.
-
-==============================================================================
-CONFIGURATION                                                *preview-config*
-
-Configure by setting |vim.g.preview| to a table where keys are preset names
-or filetypes. For each key `k` with value `v` (excluding `debug`):
-
-  - If `k` is a preset name and `v` is `true`, the preset is registered
-    as-is under its filetype.
-  - If `k` is a preset name and `v` is a table, it is deep-merged with
-    the preset and registered under the preset's filetype.
-  - If `k` is not a preset name and `v` is a table, it is registered
-    directly as a custom provider keyed by filetype `k`.
-  - If `v` is `false`, the entry is skipped (no-op).
-
-See |preview-presets| for available preset names.
-
-                                                    *preview.ProviderConfig*
-Provider fields: ~
-
-  {cmd}              (string[])         Compiler command (required).
-
-  {args}             (string[]|function) Additional arguments. If a function,
-                                        receives a |preview.Context| and
-                                        returns a string[].
-
-  {cwd}              (string|function)  Working directory. If a function,
-                                        receives a |preview.Context|.
-                                        Default: git root or file directory.
-
-  {env}              (table)            Environment variables.
-
-  {output}           (string|function)  Output file path. If a function,
-                                        receives a |preview.Context|.
-
-  {error_parser}     (function)         Receives (output, |preview.Context|)
-                                        and returns vim.Diagnostic[].
-
-  {errors}           (false|'diagnostic'|'quickfix')
-                                        How parse errors are reported.
-                                        `false` suppresses error handling.
-                                        `'quickfix'` populates the quickfix
-                                        list and opens it.
-                                        Default: `'diagnostic'`.
-
-  {clean}            (string[]|function) Command to remove build artifacts.
-                                        If a function, receives a
-                                        |preview.Context|.
-
-  {open}             (boolean|string[]) Open the output file after the first
-                                        successful compilation in toggle/watch
-                                        mode. `true` uses |vim.ui.open()|. A
-                                        string[] is run as a command with the
-                                        output path appended. When a string[]
-                                        is used the viewer process is tracked
-                                        and sent SIGTERM when the buffer is
-                                        deleted. `true` and single-instance
-                                        apps (e.g. Chrome) do not support
-                                        auto-close.
-
-  {reload}           (boolean|string[]|function)
-                                        Reload the output after recompilation.
-                                        `true` uses a built-in SSE server for
-                                        HTML files. A string[] is run as a
-                                        command. If a function, receives a
-                                        |preview.Context| and returns a
-                                        string[].
-
-  {detach}           (boolean)          When `true`, the viewer process opened
-                                        via a string[] `open` command is not
-                                        sent SIGTERM when the buffer is
-                                        deleted. Has no effect when `open` is
-                                        `true`. Default: `false`.
-
-                                                        *preview.Context*
-Context fields: ~
-
-  {bufnr}   (integer)   Buffer number.
-  {file}    (string)    Absolute file path.
-  {root}    (string)    Project root (git root or file directory).
-  {ft}      (string)    Filetype.
-  {output}  (string?)   Resolved output file path (set after `output`
-                        is evaluated, available to `args` functions).
-
-Global options: ~
-
-  {debug}   (boolean|string) Enable debug logging. A string value is treated
-                             as a log file path. Default: `false`.
-
-Example enabling presets: >lua
-    vim.g.preview = { typst = true, latex = true, github = true }
-<
-
-Example overriding a preset field: >lua
-    vim.g.preview = {
-      typst = { open = { 'sioyek', '--new-instance' } },
-    }
-<
-
-Example overriding the output path (e.g. latexmk `$out_dir`): >lua
-    vim.g.preview = {
-      latex = {
-        output = function(ctx)
-          return 'build/' .. vim.fn.fnamemodify(ctx.file, ':t:r') .. '.pdf'
-        end,
-      },
-    }
-<
-
-Example with a fully custom provider (key is not a preset name): >lua
-    vim.g.preview = {
-      rst = {
-        cmd = { 'rst2html' },
-        args = function(ctx)
-          return { ctx.file }
-        end,
-        output = function(ctx)
-          return ctx.file:gsub('%.rst$', '.html')
-        end,
-      },
-    }
-<
-
-==============================================================================
-PRESETS                                                    *preview-presets*
-
-Built-in provider configurations. Enable with `preset_name = true` or
-override individual fields by passing a table instead: >lua
-    vim.g.preview = { typst = true, latex = true, github = true }
-<
-
-  `typst`              typst compile → PDF
-  `latex`              latexmk -pdf → PDF (with clean support)
-  `pdflatex`           pdflatex → PDF (single pass, no latexmk)
-  `tectonic`           tectonic → PDF (Rust-based LaTeX engine)
-  `markdown`           pandoc → HTML (standalone, embedded)
-  `github`             pandoc → HTML (GitHub-styled, `-f gfm` input)
-  `asciidoctor`        asciidoctor → HTML (AsciiDoc with SSE reload)
-  `plantuml`           plantuml → SVG (UML diagrams, `.puml`)
-  `mermaid`            mmdc → SVG (Mermaid diagrams, `.mmd`)
-  `quarto`             quarto render → HTML (scientific publishing)
-
-==============================================================================
-COMMANDS                                                  *preview-commands*
-
-:Preview [subcommand]                                             *:Preview*
-
-    Subcommands: ~
-
-    `toggle`     Toggle auto-compile on save (default if omitted).
-    `compile`    One-shot compile of the current buffer.
-    `clean`      Run the provider's clean command.
-    `open`       Open the last compiled output without recompiling.
-    `status`     Echo compilation status (idle, compiling, watching).
-
-==============================================================================
-LUA API                                                        *preview-api*
-
-preview.toggle({bufnr?})                                  *preview.toggle()*
-    Toggle auto-compile for the buffer. When enabled, the buffer is
-    immediately compiled and automatically recompiled on each save
-    (`BufWritePost`). Call again to stop.
-
-preview.compile({bufnr?})                                *preview.compile()*
-    One-shot compile the document in the given buffer (default: current).
-
-preview.stop({bufnr?})                                      *preview.stop()*
-    Kill the active compilation process for the buffer. Programmatic
-    escape hatch — not exposed as a subcommand.
-
-preview.clean({bufnr?})                                    *preview.clean()*
-    Run the provider's clean command for the buffer.
-
-preview.open({bufnr?})                                      *preview.open()*
-    Open the last compiled output for the buffer without recompiling.
-
-preview.status({bufnr?})                                  *preview.status()*
-    Returns a |preview.Status| table.
-
-preview.statusline({bufnr?})                          *preview.statusline()*
-    Returns a short status string for statusline integration:
-    `'compiling'`, `'watching'`, or `''` (idle).
-
-preview.get_config()                                  *preview.get_config()*
-    Returns the resolved |preview.Config|.
-
-                                                          *preview.Status*
-Status fields: ~
-
-  {compiling}    (boolean)   Whether compilation is active.
-  {watching}     (boolean)   Whether auto-compile is active.
-  {provider}     (string?)   Name of the active provider.
-  {output_file}  (string?)   Path to the output file.
-
-==============================================================================
-EVENTS                                                      *preview-events*
-
-preview.nvim fires User autocmds with structured data:
-
-`PreviewCompileStarted`  Compilation began.
-                        data: `{ bufnr, provider }`
-
-`PreviewCompileSuccess`  Compilation succeeded (exit code 0).
-                        data: `{ bufnr, provider, output }`
-
-`PreviewCompileFailed`   Compilation failed (non-zero exit).
-                        data: `{ bufnr, provider, code, stderr }`
-
-Example: >lua
-    vim.api.nvim_create_autocmd('User', {
-      pattern = 'PreviewCompileSuccess',
-      callback = function(args)
-        local data = args.data
-        vim.notify('Compiled ' .. data.output .. ' with ' .. data.provider)
-      end,
-    })
-<
-
-==============================================================================
-HEALTH                                                      *preview-health*
-
-Run |:checkhealth| preview to verify your setup: >vim
-    :checkhealth preview
-<
-
-Checks: ~
-- Neovim version >= 0.11.0
-- Each configured provider's binary is executable
-- Each configured provider's opener binary (if any) is executable
-
-==============================================================================
- vim:tw=78:ts=8:ft=help:norl:

flake.nix

@@ -13,15 +13,12 @@
       ...
     }:
     let
-      forEachSystem =
+      forEachSystem = f: nixpkgs.lib.genAttrs (import systems) (system: f nixpkgs.legacyPackages.${system});
-        f: nixpkgs.lib.genAttrs (import systems) (system: f nixpkgs.legacyPackages.${system});
     in
     {
-      formatter = forEachSystem (pkgs: pkgs.nixfmt-tree);
+      devShells = forEachSystem (pkgs: {
-
+        default = pkgs.mkShell {
-      devShells = forEachSystem (pkgs:
+          packages = [
-        let
-          devTools = [
             (pkgs.luajit.withPackages (
               ps: with ps; [
                 busted
@@ -33,22 +30,6 @@
             pkgs.selene
             pkgs.lua-language-server
           ];
-        in
-        {
-          default = pkgs.mkShell {
-            packages = devTools;
-          };
-          presets = pkgs.mkShell {
-            packages = devTools ++ [
-              pkgs.typst
-              pkgs.texliveMedium
-              pkgs.tectonic
-              pkgs.pandoc
-              pkgs.asciidoctor
-              pkgs.quarto
-              pkgs.plantuml
-              pkgs.mermaid-cli
-            ];
         };
       });
     };

lua/preview/commands.lua

@@ -1,19 +1,20 @@
 local M = {}
 
-local handlers = {
+local subcommands = { 'compile', 'stop', 'clean', 'toggle', 'status' }
-  compile = function()
+
+---@param args string
+local function dispatch(args)
+  local subcmd = args ~= '' and args or 'compile'
+
+  if subcmd == 'compile' then
     require('preview').compile()
-  end,
+  elseif subcmd == 'stop' then
-  clean = function()
+    require('preview').stop()
+  elseif subcmd == 'clean' then
     require('preview').clean()
-  end,
+  elseif subcmd == 'toggle' then
-  toggle = function()
     require('preview').toggle()
-  end,
+  elseif subcmd == 'status' then
-  open = function()
-    require('preview').open()
-  end,
-  status = function()
     local s = require('preview').status()
     local parts = {}
     if s.compiling then
@@ -24,18 +25,9 @@ local handlers = {
     if s.watching then
       table.insert(parts, 'watching')
     end
-    vim.notify('[preview.nvim]: ' .. table.concat(parts, ', '), vim.log.levels.INFO)
+    vim.notify('[preview.nvim] ' .. table.concat(parts, ', '), vim.log.levels.INFO)
-  end,
-}
-
----@param args string
-local function dispatch(args)
-  local subcmd = args ~= '' and args or 'toggle'
-  local handler = handlers[subcmd]
-  if handler then
-    handler()
   else
-    vim.notify('[preview.nvim]: unknown subcommand: ' .. subcmd, vim.log.levels.ERROR)
+    vim.notify('[preview.nvim] unknown subcommand: ' .. subcmd, vim.log.levels.ERROR)
   end
 end
 
@@ -44,7 +36,7 @@ end
 local function complete(lead)
   return vim.tbl_filter(function(s)
     return s:find(lead, 1, true) == 1
-  end, vim.tbl_keys(handlers))
+  end, subcommands)
 end
 
 function M.setup()
@@ -55,13 +47,7 @@ function M.setup()
     complete = function(lead)
       return complete(lead)
     end,
-    desc = 'Toggle, compile, clean, open, or check status of document preview',
+    desc = 'Compile, stop, clean, toggle, or check status of document preview',
-  })
-
-  vim.api.nvim_create_autocmd('VimLeavePre', {
-    callback = function()
-      require('preview.compiler').stop_all()
-    end,
   })
 end
 

lua/preview/compiler.lua

@@ -12,52 +12,6 @@ local watching = {}
 ---@type table<integer, true>
 local opened = {}
 
----@type table<integer, string>
-local last_output = {}
-
----@type table<integer, table>
-local viewer_procs = {}
-
----@type table<integer, uv.uv_fs_event_t>
-local open_watchers = {}
-
-local debounce_timers = {}
-
-local DEBOUNCE_MS = 500
-
----@param bufnr integer
-local function stop_open_watcher(bufnr)
-  local w = open_watchers[bufnr]
-  if w then
-    w:stop()
-    w:close()
-    open_watchers[bufnr] = nil
-  end
-end
-
----@param bufnr integer
-local function close_viewer(bufnr)
-  local obj = viewer_procs[bufnr]
-  if obj then
-    local kill = obj.kill
-    kill(obj, 'sigterm')
-    viewer_procs[bufnr] = nil
-  end
-end
-
----@param bufnr integer
----@param output_file string
----@param open_config boolean|string[]
-local function do_open(bufnr, output_file, open_config)
-  if open_config == true then
-    vim.ui.open(output_file)
-  elseif type(open_config) == 'table' then
-    local open_cmd = vim.list_extend({}, open_config)
-    table.insert(open_cmd, output_file)
-    viewer_procs[bufnr] = vim.system(open_cmd)
-  end
-end
-
 ---@param val string[]|fun(ctx: preview.Context): string[]
 ---@param ctx preview.Context
 ---@return string[]
@@ -78,33 +32,11 @@ local function eval_string(val, ctx)
   return val
 end
 
----@param provider preview.ProviderConfig
----@param ctx preview.Context
----@return string[]?
-local function resolve_reload_cmd(provider, ctx)
-  if type(provider.reload) == 'function' then
-    return provider.reload(ctx)
-  elseif type(provider.reload) == 'table' then
-    return vim.list_extend({}, provider.reload)
-  end
-  return nil
-end
-
 ---@param bufnr integer
 ---@param name string
 ---@param provider preview.ProviderConfig
 ---@param ctx preview.Context
-function M.compile(bufnr, name, provider, ctx, opts)
+function M.compile(bufnr, name, provider, ctx)
-  opts = opts or {}
-
-  if vim.fn.executable(provider.cmd[1]) ~= 1 then
-    vim.notify(
-      '[preview.nvim]: "' .. provider.cmd[1] .. '" is not executable (run :checkhealth preview)',
-      vim.log.levels.ERROR
-    )
-    return
-  end
-
   if vim.bo[bufnr].modified then
     vim.cmd('silent! update')
   end
@@ -114,277 +46,56 @@ function M.compile(bufnr, name, provider, ctx, opts)
     M.stop(bufnr)
   end
 
+  local cmd = vim.list_extend({}, provider.cmd)
+  if provider.args then
+    vim.list_extend(cmd, eval_list(provider.args, ctx))
+  end
+
+  local cwd = ctx.root
+  if provider.cwd then
+    cwd = eval_string(provider.cwd, ctx)
+  end
+
   local output_file = ''
   if provider.output then
     output_file = eval_string(provider.output, ctx)
   end
 
-  local resolved_ctx = vim.tbl_extend('force', ctx, { output = output_file })
-
-  local cwd = ctx.root
-  if provider.cwd then
-    cwd = eval_string(provider.cwd, resolved_ctx)
-  end
-
-  if output_file ~= '' then
-    last_output[bufnr] = output_file
-  end
-
-  local reload_cmd
-  if not opts.oneshot then
-    reload_cmd = resolve_reload_cmd(provider, resolved_ctx)
-  end
-
-  if reload_cmd then
-    log.dbg(
-      'starting long-running process for buffer %d with provider "%s": %s',
-      bufnr,
-      name,
-      table.concat(reload_cmd, ' ')
-    )
-
-    local stderr_acc = {}
-    local obj
-    obj = vim.system(
-      reload_cmd,
-      {
-        cwd = cwd,
-        env = provider.env,
-        stderr = vim.schedule_wrap(function(_err, data)
-          if not data or not vim.api.nvim_buf_is_valid(bufnr) then
-            return
-          end
-          stderr_acc[#stderr_acc + 1] = data
-          local errors_mode = provider.errors
-          if errors_mode == nil then
-            errors_mode = 'diagnostic'
-          end
-          if provider.error_parser and errors_mode then
-            local output = table.concat(stderr_acc)
-            if errors_mode == 'diagnostic' then
-              diagnostic.set(bufnr, name, provider.error_parser, output, ctx)
-            elseif errors_mode == 'quickfix' then
-              local ok, diags = pcall(provider.error_parser, output, ctx)
-              if ok and diags and #diags > 0 then
-                local items = {}
-                for _, d in ipairs(diags) do
-                  table.insert(items, {
-                    bufnr = bufnr,
-                    lnum = d.lnum + 1,
-                    col = d.col + 1,
-                    text = d.message,
-                    type = d.severity == vim.diagnostic.severity.WARN and 'W' or 'E',
-                  })
-                end
-                vim.fn.setqflist(items, 'r')
-                local win = vim.fn.win_getid()
-                vim.cmd.cwindow()
-                vim.fn.win_gotoid(win)
-              end
-            end
-          end
-        end),
-      },
-      vim.schedule_wrap(function(result)
-        if active[bufnr] and active[bufnr].obj == obj then
-          active[bufnr] = nil
-        end
-        if not vim.api.nvim_buf_is_valid(bufnr) then
-          return
-        end
-
-        if result.code ~= 0 then
-          log.dbg('long-running process failed for buffer %d (exit code %d)', bufnr, result.code)
-          local errors_mode = provider.errors
-          if errors_mode == nil then
-            errors_mode = 'diagnostic'
-          end
-          if provider.error_parser and errors_mode then
-            local output = (result.stdout or '') .. (result.stderr or '')
-            if errors_mode == 'diagnostic' then
-              diagnostic.set(bufnr, name, provider.error_parser, output, ctx)
-            elseif errors_mode == 'quickfix' then
-              local ok, diagnostics = pcall(provider.error_parser, output, ctx)
-              if ok and diagnostics and #diagnostics > 0 then
-                local items = {}
-                for _, d in ipairs(diagnostics) do
-                  table.insert(items, {
-                    bufnr = bufnr,
-                    lnum = d.lnum + 1,
-                    col = d.col + 1,
-                    text = d.message,
-                    type = d.severity == vim.diagnostic.severity.WARN and 'W' or 'E',
-                  })
-                end
-                vim.fn.setqflist(items, 'r')
-                local win = vim.fn.win_getid()
-                vim.cmd.cwindow()
-                vim.fn.win_gotoid(win)
-              end
-            end
-          end
-          vim.api.nvim_exec_autocmds('User', {
-            pattern = 'PreviewCompileFailed',
-            data = {
-              bufnr = bufnr,
-              provider = name,
-              code = result.code,
-              stderr = result.stderr or '',
-            },
-          })
-        end
-      end)
-    )
-
-    if provider.open and not opts.oneshot and not opened[bufnr] and output_file ~= '' then
-      local pre_stat = vim.uv.fs_stat(output_file)
-      local pre_mtime = pre_stat and pre_stat.mtime.sec or 0
-      local out_dir = vim.fn.fnamemodify(output_file, ':h')
-      local out_name = vim.fn.fnamemodify(output_file, ':t')
-      stop_open_watcher(bufnr)
-      local watcher = vim.uv.new_fs_event()
-      if watcher then
-        open_watchers[bufnr] = watcher
-        watcher:start(
-          out_dir,
-          {},
-          vim.schedule_wrap(function(err, filename, _events)
-            if err or vim.fn.fnamemodify(filename or '', ':t') ~= out_name then
-              return
-            end
-            if opened[bufnr] then
-              stop_open_watcher(bufnr)
-              return
-            end
-            if not vim.api.nvim_buf_is_valid(bufnr) then
-              stop_open_watcher(bufnr)
-              return
-            end
-            local new_stat = vim.uv.fs_stat(output_file)
-            if not (new_stat and new_stat.mtime.sec > pre_mtime) then
-              return
-            end
-            stop_open_watcher(bufnr)
-            stderr_acc = {}
-            local errors_mode = provider.errors
-            if errors_mode == nil then
-              errors_mode = 'diagnostic'
-            end
-            if errors_mode == 'diagnostic' then
-              diagnostic.clear(bufnr)
-            elseif errors_mode == 'quickfix' then
-              vim.fn.setqflist({}, 'r')
-              vim.cmd.cwindow()
-            end
-            do_open(bufnr, output_file, provider.open)
-            opened[bufnr] = true
-          end)
-        )
-      end
-    end
-
-    active[bufnr] = { obj = obj, provider = name, output_file = output_file, is_reload = true }
-
-    vim.api.nvim_create_autocmd('BufUnload', {
-      buffer = bufnr,
-      once = true,
-      callback = function()
-        M.stop(bufnr)
-        stop_open_watcher(bufnr)
-        if not provider.detach then
-          close_viewer(bufnr)
-        end
-        last_output[bufnr] = nil
-      end,
-    })
-
-    vim.api.nvim_exec_autocmds('User', {
-      pattern = 'PreviewCompileStarted',
-      data = { bufnr = bufnr, provider = name },
-    })
-    return
-  end
-
-  local cmd = vim.list_extend({}, provider.cmd)
-  if provider.args then
-    vim.list_extend(cmd, eval_list(provider.args, resolved_ctx))
-  end
-
   log.dbg('compiling buffer %d with provider "%s": %s', bufnr, name, table.concat(cmd, ' '))
 
-  local obj
+  local obj = vim.system(
-  obj = vim.system(
     cmd,
     {
       cwd = cwd,
       env = provider.env,
     },
     vim.schedule_wrap(function(result)
-      if active[bufnr] and active[bufnr].obj == obj then
       active[bufnr] = nil
-      end
       if not vim.api.nvim_buf_is_valid(bufnr) then
         return
       end
 
-      local errors_mode = provider.errors
-      if errors_mode == nil then
-        errors_mode = 'diagnostic'
-      end
-
       if result.code == 0 then
         log.dbg('compilation succeeded for buffer %d', bufnr)
-        if errors_mode == 'diagnostic' then
         diagnostic.clear(bufnr)
-        elseif errors_mode == 'quickfix' then
-          vim.fn.setqflist({}, 'r')
-          vim.cmd.cwindow()
-        end
         vim.api.nvim_exec_autocmds('User', {
           pattern = 'PreviewCompileSuccess',
           data = { bufnr = bufnr, provider = name, output = output_file },
         })
-        if provider.reload == true and output_file:match('%.html$') then
+        if provider.open and not opened[bufnr] and output_file ~= '' then
-          local r = require('preview.reload')
+          if provider.open == true then
-          r.start()
+            vim.ui.open(output_file)
-          r.inject(output_file)
+          elseif type(provider.open) == 'table' then
-          r.broadcast()
+            local open_cmd = vim.list_extend({}, provider.open)
+            table.insert(open_cmd, output_file)
+            vim.system(open_cmd)
           end
-        if
-          provider.open
-          and not opts.oneshot
-          and not opened[bufnr]
-          and output_file ~= ''
-          and vim.uv.fs_stat(output_file)
-        then
-          do_open(bufnr, output_file, provider.open)
           opened[bufnr] = true
         end
       else
         log.dbg('compilation failed for buffer %d (exit code %d)', bufnr, result.code)
-        if provider.error_parser and errors_mode then
+        if provider.error_parser then
-          local output = (result.stdout or '') .. (result.stderr or '')
+          diagnostic.set(bufnr, name, provider.error_parser, result.stderr or '', ctx)
-          if errors_mode == 'diagnostic' then
-            diagnostic.set(bufnr, name, provider.error_parser, output, ctx)
-          elseif errors_mode == 'quickfix' then
-            local ok, diagnostics = pcall(provider.error_parser, output, ctx)
-            if ok and diagnostics and #diagnostics > 0 then
-              local items = {}
-              for _, d in ipairs(diagnostics) do
-                table.insert(items, {
-                  bufnr = bufnr,
-                  lnum = d.lnum + 1,
-                  col = d.col + 1,
-                  text = d.message,
-                  type = d.severity == vim.diagnostic.severity.WARN and 'W' or 'E',
-                })
-              end
-              vim.fn.setqflist(items, 'r')
-              local win = vim.fn.win_getid()
-              vim.cmd.cwindow()
-              vim.fn.win_gotoid(win)
-            end
-          end
         end
         vim.api.nvim_exec_autocmds('User', {
           pattern = 'PreviewCompileFailed',
@@ -401,15 +112,11 @@ function M.compile(bufnr, name, provider, ctx, opts)
 
   active[bufnr] = { obj = obj, provider = name, output_file = output_file }
 
-  vim.api.nvim_create_autocmd('BufUnload', {
+  vim.api.nvim_create_autocmd('BufWipeout', {
     buffer = bufnr,
     once = true,
     callback = function()
       M.stop(bufnr)
-      if not provider.detach then
-        close_viewer(bufnr)
-      end
-      last_output[bufnr] = nil
     end,
   })
 
@@ -449,13 +156,6 @@ function M.stop_all()
   for bufnr, _ in pairs(watching) do
     M.unwatch(bufnr)
   end
-  for bufnr, _ in pairs(open_watchers) do
-    stop_open_watcher(bufnr)
-  end
-  for bufnr, _ in pairs(viewer_procs) do
-    close_viewer(bufnr)
-  end
-  require('preview.reload').stop()
 end
 
 ---@param bufnr integer
@@ -463,57 +163,27 @@ end
 ---@param provider preview.ProviderConfig
 ---@param ctx_builder fun(bufnr: integer): preview.Context
 function M.toggle(bufnr, name, provider, ctx_builder)
-  local is_longrunning = type(provider.reload) == 'table' or type(provider.reload) == 'function'
-
-  if is_longrunning then
-    if active[bufnr] then
-      M.stop(bufnr)
-      vim.notify('[preview.nvim]: watching stopped', vim.log.levels.INFO)
-    else
-      M.compile(bufnr, name, provider, ctx_builder(bufnr))
-      vim.notify('[preview.nvim]: watching with "' .. name .. '"', vim.log.levels.INFO)
-    end
-    return
-  end
-
   if watching[bufnr] then
     M.unwatch(bufnr)
-    vim.notify('[preview.nvim]: watching stopped', vim.log.levels.INFO)
     return
   end
 
   local au_id = vim.api.nvim_create_autocmd('BufWritePost', {
     buffer = bufnr,
     callback = function()
-      if debounce_timers[bufnr] then
-        debounce_timers[bufnr]:stop()
-      else
-        debounce_timers[bufnr] = vim.uv.new_timer()
-      end
-      debounce_timers[bufnr]:start(
-        DEBOUNCE_MS,
-        0,
-        vim.schedule_wrap(function()
       local ctx = ctx_builder(bufnr)
       M.compile(bufnr, name, provider, ctx)
-        end)
-      )
     end,
   })
 
   watching[bufnr] = au_id
   log.dbg('watching buffer %d with provider "%s"', bufnr, name)
-  vim.notify('[preview.nvim]: watching with "' .. name .. '"', vim.log.levels.INFO)
 
-  vim.api.nvim_create_autocmd('BufUnload', {
+  vim.api.nvim_create_autocmd('BufWipeout', {
     buffer = bufnr,
     once = true,
     callback = function()
       M.unwatch(bufnr)
-      stop_open_watcher(bufnr)
-      if not provider.detach then
-        close_viewer(bufnr)
-      end
       opened[bufnr] = nil
     end,
   })
@@ -528,11 +198,6 @@ function M.unwatch(bufnr)
     return
   end
   vim.api.nvim_del_autocmd(au_id)
-  if debounce_timers[bufnr] then
-    debounce_timers[bufnr]:stop()
-    debounce_timers[bufnr]:close()
-    debounce_timers[bufnr] = nil
-  end
   watching[bufnr] = nil
   log.dbg('unwatched buffer %d', bufnr)
 end
@@ -543,23 +208,14 @@ end
 ---@param ctx preview.Context
 function M.clean(bufnr, name, provider, ctx)
   if not provider.clean then
-    vim.notify(
+    vim.notify('[preview.nvim] provider "' .. name .. '" has no clean command', vim.log.levels.WARN)
-      '[preview.nvim]: provider "' .. name .. '" has no clean command',
-      vim.log.levels.WARN
-    )
     return
   end
 
-  local output_file = ''
+  local cmd = eval_list(provider.clean, ctx)
-  if provider.output then
+  local cwd = ctx.root
-    output_file = eval_string(provider.output, ctx)
-  end
-  local resolved_ctx = vim.tbl_extend('force', ctx, { output = output_file })
-
-  local cmd = eval_list(provider.clean, resolved_ctx)
-  local cwd = resolved_ctx.root
   if provider.cwd then
-    cwd = eval_string(provider.cwd, resolved_ctx)
+    cwd = eval_string(provider.cwd, ctx)
   end
 
   log.dbg('cleaning buffer %d with provider "%s": %s', bufnr, name, table.concat(cmd, ' '))
@@ -570,39 +226,23 @@ function M.clean(bufnr, name, provider, ctx)
     vim.schedule_wrap(function(result)
       if result.code == 0 then
         log.dbg('clean succeeded for buffer %d', bufnr)
-        vim.notify('[preview.nvim]: clean complete', vim.log.levels.INFO)
+        vim.notify('[preview.nvim] clean complete', vim.log.levels.INFO)
       else
         log.dbg('clean failed for buffer %d (exit code %d)', bufnr, result.code)
-        vim.notify('[preview.nvim]: clean failed: ' .. (result.stderr or ''), vim.log.levels.ERROR)
+        vim.notify('[preview.nvim] clean failed: ' .. (result.stderr or ''), vim.log.levels.ERROR)
       end
     end)
   )
 end
 
----@param bufnr integer
----@return boolean
-function M.open(bufnr, open_config)
-  local output = last_output[bufnr]
-  if not output then
-    log.dbg('no last output file for buffer %d', bufnr)
-    return false
-  end
-  if not vim.uv.fs_stat(output) then
-    log.dbg('output file no longer exists for buffer %d: %s', bufnr, output)
-    return false
-  end
-  do_open(bufnr, output, open_config)
-  return true
-end
-
 ---@param bufnr integer
 ---@return preview.Status
 function M.status(bufnr)
   local proc = active[bufnr]
   if proc then
     return {
-      compiling = not proc.is_reload,
+      compiling = true,
-      watching = watching[bufnr] ~= nil or proc.is_reload == true,
+      watching = watching[bufnr] ~= nil,
       provider = proc.provider,
       output_file = proc.output_file,
     }
@@ -614,10 +254,6 @@ M._test = {
   active = active,
   watching = watching,
   opened = opened,
-  last_output = last_output,
-  debounce_timers = debounce_timers,
-  viewer_procs = viewer_procs,
-  open_watchers = open_watchers,
 }
 
 return M

lua/preview/diagnostic.lua

@@ -12,11 +12,11 @@ end
 
 ---@param bufnr integer
 ---@param name string
----@param error_parser fun(output: string, ctx: preview.Context): preview.Diagnostic[]
+---@param error_parser fun(stderr: string, ctx: preview.Context): preview.Diagnostic[]
----@param output string
+---@param stderr string
 ---@param ctx preview.Context
-function M.set(bufnr, name, error_parser, output, ctx)
+function M.set(bufnr, name, error_parser, stderr, ctx)
-  local ok, diagnostics = pcall(error_parser, output, ctx)
+  local ok, diagnostics = pcall(error_parser, stderr, ctx)
   if not ok then
     log.dbg('error_parser for "%s" failed: %s', name, diagnostics)
     return

lua/preview/init.lua

@@ -5,12 +5,9 @@
 ---@field cwd? string|fun(ctx: preview.Context): string
 ---@field env? table<string, string>
 ---@field output? string|fun(ctx: preview.Context): string
----@field error_parser? fun(output: string, ctx: preview.Context): preview.Diagnostic[]
+---@field error_parser? fun(stderr: string, ctx: preview.Context): preview.Diagnostic[]
----@field errors? false|'diagnostic'|'quickfix'
 ---@field clean? string[]|fun(ctx: preview.Context): string[]
 ---@field open? boolean|string[]
----@field reload? boolean|string[]|fun(ctx: preview.Context): string[]
----@field detach? boolean
 
 ---@class preview.Config
 ---@field debug boolean|string
@@ -21,7 +18,6 @@
 ---@field file string
 ---@field root string
 ---@field ft string
----@field output? string
 
 ---@class preview.Diagnostic
 ---@field lnum integer
@@ -36,7 +32,6 @@
 ---@field obj table
 ---@field provider string
 ---@field output_file string
----@field is_reload? boolean
 
 ---@class preview
 ---@field setup fun(opts?: table)
@@ -44,9 +39,7 @@
 ---@field stop fun(bufnr?: integer)
 ---@field clean fun(bufnr?: integer)
 ---@field toggle fun(bufnr?: integer)
----@field open fun(bufnr?: integer)
 ---@field status fun(bufnr?: integer): preview.Status
----@field statusline fun(bufnr?: integer): string
 ---@field get_config fun(): preview.Config
 local M = {}
 
@@ -89,28 +82,6 @@ function M.setup(opts)
     end
   end
 
-  for ft, provider in pairs(providers) do
-    local prefix = 'providers.' .. ft
-    vim.validate(prefix .. '.cmd', provider.cmd, 'table')
-    vim.validate(prefix .. '.cmd[1]', provider.cmd[1], 'string')
-    vim.validate(prefix .. '.args', provider.args, { 'table', 'function' }, true)
-    vim.validate(prefix .. '.cwd', provider.cwd, { 'string', 'function' }, true)
-    vim.validate(prefix .. '.output', provider.output, { 'string', 'function' }, true)
-    vim.validate(prefix .. '.error_parser', provider.error_parser, 'function', true)
-    vim.validate(prefix .. '.errors', provider.errors, function(x)
-      return x == nil or x == false or x == 'diagnostic' or x == 'quickfix'
-    end, 'false, "diagnostic", or "quickfix"')
-    vim.validate(prefix .. '.open', provider.open, { 'boolean', 'table' }, true)
-    vim.validate(prefix .. '.reload', provider.reload, { 'boolean', 'table', 'function' }, true)
-    vim.validate(prefix .. '.detach', provider.detach, 'boolean', true)
-  end
-
-  if providers['plantuml'] then
-    vim.filetype.add({
-      extension = { puml = 'plantuml', pu = 'plantuml' },
-    })
-  end
-
   config = vim.tbl_deep_extend('force', default_config, {
     debug = debug,
     providers = providers,
@@ -154,18 +125,14 @@ end
 ---@param bufnr? integer
 function M.compile(bufnr)
   bufnr = bufnr or vim.api.nvim_get_current_buf()
-  if vim.api.nvim_buf_get_name(bufnr) == '' then
-    vim.notify('[preview.nvim]: buffer has no file name', vim.log.levels.WARN)
-    return
-  end
   local name = M.resolve_provider(bufnr)
   if not name then
-    vim.notify('[preview.nvim]: no provider configured for this filetype', vim.log.levels.WARN)
+    vim.notify('[preview.nvim] no provider configured for this filetype', vim.log.levels.WARN)
     return
   end
   local ctx = M.build_context(bufnr)
   local provider = config.providers[name]
-  compiler.compile(bufnr, name, provider, ctx, { oneshot = true })
+  compiler.compile(bufnr, name, provider, ctx)
 end
 
 ---@param bufnr? integer
@@ -177,13 +144,9 @@ end
 ---@param bufnr? integer
 function M.clean(bufnr)
   bufnr = bufnr or vim.api.nvim_get_current_buf()
-  if vim.api.nvim_buf_get_name(bufnr) == '' then
-    vim.notify('[preview.nvim]: buffer has no file name', vim.log.levels.WARN)
-    return
-  end
   local name = M.resolve_provider(bufnr)
   if not name then
-    vim.notify('[preview.nvim]: no provider configured for this filetype', vim.log.levels.WARN)
+    vim.notify('[preview.nvim] no provider configured for this filetype', vim.log.levels.WARN)
     return
   end
   local ctx = M.build_context(bufnr)
@@ -194,33 +157,15 @@ end
 ---@param bufnr? integer
 function M.toggle(bufnr)
   bufnr = bufnr or vim.api.nvim_get_current_buf()
-  if vim.api.nvim_buf_get_name(bufnr) == '' then
-    vim.notify('[preview.nvim]: buffer has no file name', vim.log.levels.WARN)
-    return
-  end
   local name = M.resolve_provider(bufnr)
   if not name then
-    vim.notify('[preview.nvim]: no provider configured for this filetype', vim.log.levels.WARN)
+    vim.notify('[preview.nvim] no provider configured for this filetype', vim.log.levels.WARN)
     return
   end
   local provider = config.providers[name]
   compiler.toggle(bufnr, name, provider, M.build_context)
 end
 
----@param bufnr? integer
-function M.open(bufnr)
-  bufnr = bufnr or vim.api.nvim_get_current_buf()
-  if vim.api.nvim_buf_get_name(bufnr) == '' then
-    vim.notify('[preview.nvim]: buffer has no file name', vim.log.levels.WARN)
-    return
-  end
-  local name = M.resolve_provider(bufnr)
-  local open_config = name and config.providers[name] and config.providers[name].open
-  if not compiler.open(bufnr, open_config) then
-    vim.notify('[preview.nvim]: no output file available for this buffer', vim.log.levels.WARN)
-  end
-end
-
 ---@class preview.Status
 ---@field compiling boolean
 ---@field watching boolean
@@ -234,19 +179,6 @@ function M.status(bufnr)
   return compiler.status(bufnr)
 end
 
----@param bufnr? integer
----@return string
-function M.statusline(bufnr)
-  bufnr = bufnr or vim.api.nvim_get_current_buf()
-  local s = compiler.status(bufnr)
-  if s.compiling then
-    return 'compiling'
-  elseif s.watching then
-    return 'watching'
-  end
-  return ''
-end
-
 M._test = {
   ---@diagnostic disable-next-line: assign-type-mismatch
   reset = function()
@@ -254,8 +186,4 @@ M._test = {
   end,
 }
 
-if vim.g.preview then
-  M.setup(vim.g.preview)
-end
-
 return M

lua/preview/presets.lua

@@ -1,140 +1,16 @@
 local M = {}
 
----@param output string
----@return preview.Diagnostic[]
-local function parse_typst(output)
-  local diagnostics = {}
-  for line in output:gmatch('[^\r\n]+') do
-    local _, lnum, col, severity, msg = line:match('^(.+):(%d+):(%d+): (%w+): (.+)$')
-    if lnum then
-      local sev = vim.diagnostic.severity.ERROR
-      if severity == 'warning' then
-        sev = vim.diagnostic.severity.WARN
-      end
-      table.insert(diagnostics, {
-        lnum = tonumber(lnum) - 1,
-        col = tonumber(col) - 1,
-        message = msg,
-        severity = sev,
-      })
-    end
-  end
-  return diagnostics
-end
-
----@param output string
----@return preview.Diagnostic[]
-local function parse_latexmk(output)
-  local diagnostics = {}
-  for line in output:gmatch('[^\r\n]+') do
-    local _, lnum, msg = line:match('^%.?/?(.+%.tex):(%d+): (.+)$')
-    if lnum then
-      table.insert(diagnostics, {
-        lnum = tonumber(lnum) - 1,
-        col = 0,
-        message = msg,
-        severity = vim.diagnostic.severity.ERROR,
-      })
-    else
-      local rule_msg = line:match('^%s+(%S.+gave return code %d+)$')
-      if rule_msg then
-        table.insert(diagnostics, {
-          lnum = 0,
-          col = 0,
-          message = rule_msg,
-          severity = vim.diagnostic.severity.ERROR,
-        })
-      end
-    end
-  end
-  return diagnostics
-end
-
----@param output string
----@return preview.Diagnostic[]
-local function parse_pandoc(output)
-  local diagnostics = {}
-  local lines = vim.split(output, '\n')
-  local i = 1
-  while i <= #lines do
-    local line = lines[i]
-    local lnum, col, msg = line:match('%(line (%d+), column (%d+)%):%s*(.*)$')
-    if lnum then
-      if msg == '' then
-        for j = i + 1, math.min(i + 2, #lines) do
-          local next_line = lines[j]:match('^%s*(.+)$')
-          if next_line and not next_line:match('^YAML parse exception') then
-            msg = next_line
-            break
-          end
-        end
-      end
-      if msg ~= '' then
-        table.insert(diagnostics, {
-          lnum = tonumber(lnum) - 1,
-          col = tonumber(col) - 1,
-          message = msg,
-          severity = vim.diagnostic.severity.ERROR,
-        })
-      end
-    else
-      local errmsg = line:match('^pandoc: (.+)$')
-      if errmsg then
-        table.insert(diagnostics, {
-          lnum = 0,
-          col = 0,
-          message = errmsg,
-          severity = vim.diagnostic.severity.ERROR,
-        })
-      end
-    end
-    i = i + 1
-  end
-  return diagnostics
-end
-
----@param output string
----@return preview.Diagnostic[]
-local function parse_asciidoctor(output)
-  local diagnostics = {}
-  for line in output:gmatch('[^\r\n]+') do
-    local severity, _, lnum, msg = line:match('^asciidoctor: (%u+): (.+): line (%d+): (.+)$')
-    if lnum then
-      local sev = vim.diagnostic.severity.ERROR
-      if severity == 'WARNING' then
-        sev = vim.diagnostic.severity.WARN
-      end
-      table.insert(diagnostics, {
-        lnum = tonumber(lnum) - 1,
-        col = 0,
-        message = msg,
-        severity = sev,
-      })
-    end
-  end
-  return diagnostics
-end
-
 ---@type preview.ProviderConfig
 M.typst = {
   ft = 'typst',
   cmd = { 'typst', 'compile' },
   args = function(ctx)
-    return { '--diagnostic-format', 'short', ctx.file }
+    return { ctx.file }
   end,
   output = function(ctx)
     return (ctx.file:gsub('%.typ$', '.pdf'))
   end,
-  error_parser = function(output)
-    return parse_typst(output)
-  end,
-  clean = function(ctx)
-    return { 'rm', '-f', (ctx.file:gsub('%.typ$', '.pdf')) }
-  end,
   open = true,
-  reload = function(ctx)
-    return { 'typst', 'watch', '--diagnostic-format', 'short', ctx.file }
-  end,
 }
 
 ---@type preview.ProviderConfig
@@ -142,83 +18,32 @@ M.latex = {
   ft = 'tex',
   cmd = { 'latexmk' },
   args = function(ctx)
-    return {
+    return { '-pdf', '-interaction=nonstopmode', ctx.file }
-      '-pdf',
-      '-interaction=nonstopmode',
-      '-synctex=1',
-      '-pdflatex=pdflatex -file-line-error -interaction=nonstopmode %O %S',
-      ctx.file,
-    }
   end,
   output = function(ctx)
     return (ctx.file:gsub('%.tex$', '.pdf'))
   end,
-  error_parser = function(output)
-    return parse_latexmk(output)
-  end,
   clean = function(ctx)
     return { 'latexmk', '-c', ctx.file }
   end,
   open = true,
 }
 
----@type preview.ProviderConfig
-M.pdflatex = {
-  ft = 'tex',
-  cmd = { 'pdflatex' },
-  args = function(ctx)
-    return { '-interaction=nonstopmode', '-file-line-error', '-synctex=1', ctx.file }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.tex$', '.pdf'))
-  end,
-  error_parser = function(output)
-    return parse_latexmk(output)
-  end,
-  clean = function(ctx)
-    local base = ctx.file:gsub('%.tex$', '')
-    return { 'rm', '-f', base .. '.pdf', base .. '.aux', base .. '.log', base .. '.synctex.gz' }
-  end,
-  open = true,
-}
-
----@type preview.ProviderConfig
-M.tectonic = {
-  ft = 'tex',
-  cmd = { 'tectonic' },
-  args = function(ctx)
-    return { ctx.file }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.tex$', '.pdf'))
-  end,
-  error_parser = function(output)
-    return parse_latexmk(output)
-  end,
-  clean = function(ctx)
-    return { 'rm', '-f', (ctx.file:gsub('%.tex$', '.pdf')) }
-  end,
-  open = true,
-}
-
 ---@type preview.ProviderConfig
 M.markdown = {
   ft = 'markdown',
   cmd = { 'pandoc' },
   args = function(ctx)
-    return { ctx.file, '-s', '--embed-resources', '-o', ctx.output }
+    local output = ctx.file:gsub('%.md$', '.html')
+    return { ctx.file, '-s', '--embed-resources', '-o', output }
   end,
   output = function(ctx)
     return (ctx.file:gsub('%.md$', '.html'))
   end,
-  error_parser = function(output)
-    return parse_pandoc(output)
-  end,
   clean = function(ctx)
     return { 'rm', '-f', (ctx.file:gsub('%.md$', '.html')) }
   end,
   open = true,
-  reload = true,
 }
 
 ---@type preview.ProviderConfig
@@ -226,6 +51,7 @@ M.github = {
   ft = 'markdown',
   cmd = { 'pandoc' },
   args = function(ctx)
+    local output = ctx.file:gsub('%.md$', '.html')
     return {
       '-f',
       'gfm',
@@ -235,120 +61,16 @@ M.github = {
       '--css',
       'https://cdn.jsdelivr.net/gh/pixelbrackets/gfm-stylesheet@master/dist/gfm.css',
       '-o',
-      ctx.output,
+      output,
     }
   end,
   output = function(ctx)
     return (ctx.file:gsub('%.md$', '.html'))
   end,
-  error_parser = function(output)
-    return parse_pandoc(output)
-  end,
   clean = function(ctx)
     return { 'rm', '-f', (ctx.file:gsub('%.md$', '.html')) }
   end,
   open = true,
-  reload = true,
-}
-
----@type preview.ProviderConfig
-M.asciidoctor = {
-  ft = 'asciidoc',
-  cmd = { 'asciidoctor' },
-  args = function(ctx)
-    return { '--failure-level', 'ERROR', ctx.file, '-o', ctx.output }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.adoc$', '.html'))
-  end,
-  error_parser = function(output)
-    return parse_asciidoctor(output)
-  end,
-  clean = function(ctx)
-    return { 'rm', '-f', (ctx.file:gsub('%.adoc$', '.html')) }
-  end,
-  open = true,
-  reload = true,
-}
-
----@type preview.ProviderConfig
-M.plantuml = {
-  ft = 'plantuml',
-  cmd = { 'plantuml' },
-  args = function(ctx)
-    return { '-tsvg', ctx.file }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.puml$', '.svg'))
-  end,
-  error_parser = function(output)
-    local diagnostics = {}
-    for line in output:gmatch('[^\r\n]+') do
-      local lnum = line:match('^Error line (%d+) in file:')
-      if lnum then
-        table.insert(diagnostics, {
-          lnum = tonumber(lnum) - 1,
-          col = 0,
-          message = line,
-          severity = vim.diagnostic.severity.ERROR,
-        })
-      end
-    end
-    return diagnostics
-  end,
-  clean = function(ctx)
-    return { 'rm', '-f', (ctx.file:gsub('%.puml$', '.svg')) }
-  end,
-  open = true,
-}
-
----@type preview.ProviderConfig
-M.mermaid = {
-  ft = 'mermaid',
-  cmd = { 'mmdc' },
-  args = function(ctx)
-    return { '-i', ctx.file, '-o', ctx.output }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.mmd$', '.svg'))
-  end,
-  error_parser = function(output)
-    local diagnostics = {}
-    for line in output:gmatch('[^\r\n]+') do
-      local lnum = line:match('^%s*Parse error on line (%d+)')
-      if lnum then
-        table.insert(diagnostics, {
-          lnum = tonumber(lnum) - 1,
-          col = 0,
-          message = line,
-          severity = vim.diagnostic.severity.ERROR,
-        })
-      end
-    end
-    return diagnostics
-  end,
-  clean = function(ctx)
-    return { 'rm', '-f', (ctx.file:gsub('%.mmd$', '.svg')) }
-  end,
-  open = true,
-}
-
----@type preview.ProviderConfig
-M.quarto = {
-  ft = 'quarto',
-  cmd = { 'quarto' },
-  args = function(ctx)
-    return { 'render', ctx.file, '--to', 'html', '--embed-resources' }
-  end,
-  output = function(ctx)
-    return (ctx.file:gsub('%.qmd$', '.html'))
-  end,
-  clean = function(ctx)
-    local base = ctx.file:gsub('%.qmd$', '')
-    return { 'rm', '-rf', base .. '.html', base .. '_files' }
-  end,
-  open = true,
-  reload = true,
 }
 
 return M

lua/preview/reload.lua

@@ -1,113 +0,0 @@
-local M = {}
-
-local PORT = 5554
-local server_handle = nil
-local actual_port = nil
-local clients = {}
-
-local function make_script(port)
-  return '<script>(function(){'
-    .. 'var es=new EventSource("http://localhost:'
-    .. tostring(port)
-    .. '/__live/events");'
-    .. 'es.addEventListener("reload",function(){location.reload();});'
-    .. '})()</script>'
-end
-
-function M.start(port)
-  if server_handle then
-    return
-  end
-  local server = vim.uv.new_tcp()
-  server:bind('127.0.0.1', port or 0)
-  local sockname = server:getsockname()
-  if sockname then
-    actual_port = sockname.port
-  end
-  server:listen(128, function(err)
-    if err then
-      return
-    end
-    local client = vim.uv.new_tcp()
-    server:accept(client)
-    local buf = ''
-    client:read_start(function(read_err, data)
-      if read_err or not data then
-        if not client:is_closing() then
-          client:close()
-        end
-        return
-      end
-      buf = buf .. data
-      if buf:find('\r\n\r\n') or buf:find('\n\n') then
-        client:read_stop()
-        local first_line = buf:match('^([^\r\n]+)')
-        if first_line and first_line:find('/__live/events', 1, true) then
-          local response = 'HTTP/1.1 200 OK\r\n'
-            .. 'Content-Type: text/event-stream\r\n'
-            .. 'Cache-Control: no-cache\r\n'
-            .. 'Access-Control-Allow-Origin: *\r\n'
-            .. '\r\n'
-          client:write(response)
-          table.insert(clients, client)
-        else
-          client:close()
-        end
-      end
-    end)
-  end)
-  server_handle = server
-end
-
-function M.stop()
-  for _, c in ipairs(clients) do
-    if not c:is_closing() then
-      c:close()
-    end
-  end
-  clients = {}
-  if server_handle then
-    server_handle:close()
-    server_handle = nil
-  end
-  actual_port = nil
-end
-
-function M.broadcast()
-  local event = 'event: reload\ndata: {}\n\n'
-  local alive = {}
-  for _, c in ipairs(clients) do
-    if not c:is_closing() then
-      local ok = pcall(function()
-        c:write(event)
-      end)
-      if ok then
-        table.insert(alive, c)
-      end
-    end
-  end
-  clients = alive
-end
-
-function M.inject(path, port)
-  port = actual_port or port or PORT
-  local f = io.open(path, 'r')
-  if not f then
-    return
-  end
-  local content = f:read('*a')
-  f:close()
-  local script = make_script(port)
-  local new_content, n = content:gsub('</body>', script .. '\n</body>', 1)
-  if n == 0 then
-    new_content = content .. '\n' .. script
-  end
-  local fw = io.open(path, 'w')
-  if not fw then
-    return
-  end
-  fw:write(new_content)
-  fw:close()
-end
-
-return M

scripts/ci.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-set -eu
-
-nix develop --command stylua --check .
-git ls-files '*.lua' | xargs nix develop --command selene --display-style quiet
-nix develop --command prettier --check .
-nix fmt
-git diff --exit-code -- '*.nix'
-nix develop --command lua-language-server --check lua/ --configpath "$(pwd)/.luarc.json" --checklevel=Warning
-nix develop --command busted

spec/commands_spec.lua

@@ -11,29 +11,23 @@ describe('commands', function()
       local cmds = vim.api.nvim_get_commands({})
       assert.is_not_nil(cmds.Preview)
     end)
-
-    it('registers VimLeavePre autocmd', function()
-      require('preview.commands').setup()
-      local aus = vim.api.nvim_get_autocmds({ event = 'VimLeavePre' })
-      local found = false
-      for _, au in ipairs(aus) do
-        if au.callback then
-          found = true
-          break
-        end
-      end
-      assert.is_true(found)
-    end)
   end)
 
   describe('dispatch', function()
-    it('does not error on :Preview compile with no provider', function()
+    it('does not error on :Preview with no provider', function()
       require('preview.commands').setup()
       assert.has_no.errors(function()
         vim.cmd('Preview compile')
       end)
     end)
 
+    it('does not error on :Preview stop', function()
+      require('preview.commands').setup()
+      assert.has_no.errors(function()
+        vim.cmd('Preview stop')
+      end)
+    end)
+
     it('does not error on :Preview status', function()
       require('preview.commands').setup()
       assert.has_no.errors(function()
@@ -41,13 +35,6 @@ describe('commands', function()
       end)
     end)
 
-    it('does not error on :Preview open', function()
-      require('preview.commands').setup()
-      assert.has_no.errors(function()
-        vim.cmd('Preview open')
-      end)
-    end)
-
     it('does not error on :Preview toggle with no provider', function()
       require('preview.commands').setup()
       assert.has_no.errors(function()

spec/compiler_spec.lua

@@ -99,35 +99,6 @@ describe('compiler', function()
       helpers.delete_buffer(bufnr)
     end)
 
-    it('notifies and returns when binary is not executable', function()
-      local bufnr = helpers.create_buffer({ 'hello' }, 'text')
-      vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_nobin.txt')
-      vim.bo[bufnr].modified = false
-
-      local notified = false
-      local orig = vim.notify
-      vim.notify = function(msg)
-        if msg:find('not executable') then
-          notified = true
-        end
-      end
-
-      local provider = { cmd = { 'totally_nonexistent_binary_xyz_preview' } }
-      local ctx = {
-        bufnr = bufnr,
-        file = '/tmp/preview_test_nobin.txt',
-        root = '/tmp',
-        ft = 'text',
-      }
-
-      compiler.compile(bufnr, 'nobin', provider, ctx)
-      vim.notify = orig
-
-      assert.is_true(notified)
-      assert.is_nil(compiler._test.active[bufnr])
-      helpers.delete_buffer(bufnr)
-    end)
-
     it('fires PreviewCompileFailed on non-zero exit', function()
       local bufnr = helpers.create_buffer({ 'hello' }, 'text')
       vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_fail.txt')
@@ -161,108 +132,6 @@ describe('compiler', function()
     end)
   end)
 
-  describe('errors mode', function()
-    it('errors = false suppresses error parser', function()
-      local bufnr = helpers.create_buffer({ 'hello' }, 'text')
-      vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_errors_false.txt')
-      vim.bo[bufnr].modified = false
-
-      local parser_called = false
-      local provider = {
-        cmd = { 'false' },
-        errors = false,
-        error_parser = function()
-          parser_called = true
-          return {}
-        end,
-      }
-      local ctx = {
-        bufnr = bufnr,
-        file = '/tmp/preview_test_errors_false.txt',
-        root = '/tmp',
-        ft = 'text',
-      }
-
-      compiler.compile(bufnr, 'falsecmd', provider, ctx)
-
-      vim.wait(2000, function()
-        return compiler._test.active[bufnr] == nil
-      end, 50)
-
-      assert.is_false(parser_called)
-      helpers.delete_buffer(bufnr)
-    end)
-
-    it('errors = quickfix populates quickfix list', function()
-      local bufnr = helpers.create_buffer({ 'hello' }, 'text')
-      vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_errors_qf.txt')
-      vim.bo[bufnr].modified = false
-
-      local provider = {
-        cmd = { 'sh', '-c', 'echo "line 1 error" >&2; exit 1' },
-        errors = 'quickfix',
-        error_parser = function()
-          return {
-            { lnum = 0, col = 0, message = 'test error', severity = vim.diagnostic.severity.ERROR },
-          }
-        end,
-      }
-      local ctx = {
-        bufnr = bufnr,
-        file = '/tmp/preview_test_errors_qf.txt',
-        root = '/tmp',
-        ft = 'text',
-      }
-
-      vim.fn.setqflist({}, 'r')
-      compiler.compile(bufnr, 'qfcmd', provider, ctx)
-
-      vim.wait(2000, function()
-        return compiler._test.active[bufnr] == nil
-      end, 50)
-
-      local qflist = vim.fn.getqflist()
-      assert.are.equal(1, #qflist)
-      assert.are.equal('test error', qflist[1].text)
-      assert.are.equal(1, qflist[1].lnum)
-
-      vim.fn.setqflist({}, 'r')
-      helpers.delete_buffer(bufnr)
-    end)
-
-    it('errors = quickfix clears quickfix on success', function()
-      local bufnr = helpers.create_buffer({ 'hello' }, 'text')
-      vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_errors_qf_clear.txt')
-      vim.bo[bufnr].modified = false
-
-      vim.fn.setqflist({ { text = 'old error', lnum = 1 } }, 'r')
-      assert.are.equal(1, #vim.fn.getqflist())
-
-      local provider = {
-        cmd = { 'true' },
-        errors = 'quickfix',
-        error_parser = function()
-          return {}
-        end,
-      }
-      local ctx = {
-        bufnr = bufnr,
-        file = '/tmp/preview_test_errors_qf_clear.txt',
-        root = '/tmp',
-        ft = 'text',
-      }
-
-      compiler.compile(bufnr, 'truecmd', provider, ctx)
-
-      vim.wait(2000, function()
-        return compiler._test.active[bufnr] == nil
-      end, 50)
-
-      assert.are.equal(0, #vim.fn.getqflist())
-      helpers.delete_buffer(bufnr)
-    end)
-  end)
-
   describe('stop', function()
     it('does nothing when no process is active', function()
       assert.has_no.errors(function()
@@ -305,41 +174,6 @@ describe('compiler', function()
     end)
   end)
 
-  describe('open', function()
-    it('returns false when no output exists', function()
-      assert.is_false(compiler.open(999))
-    end)
-
-    it('returns true after compilation stores output', function()
-      local bufnr = helpers.create_buffer({ 'hello' }, 'text')
-      vim.api.nvim_buf_set_name(bufnr, '/tmp/preview_test_open.txt')
-      vim.bo[bufnr].modified = false
-
-      local provider = {
-        cmd = { 'true' },
-        output = function()
-          return '/tmp/preview_test_open.pdf'
-        end,
-      }
-      local ctx = {
-        bufnr = bufnr,
-        file = '/tmp/preview_test_open.txt',
-        root = '/tmp',
-        ft = 'text',
-      }
-
-      compiler.compile(bufnr, 'testprov', provider, ctx)
-      assert.is_not_nil(compiler._test.last_output[bufnr])
-      assert.are.equal('/tmp/preview_test_open.pdf', compiler._test.last_output[bufnr])
-
-      vim.wait(2000, function()
-        return compiler._test.active[bufnr] == nil
-      end, 50)
-
-      helpers.delete_buffer(bufnr)
-    end)
-  end)
-
   describe('toggle', function()
     it('registers autocmd and tracks in watching table', function()
       local bufnr = helpers.create_buffer({ 'hello' }, 'text')

spec/init_spec.lua

@@ -100,70 +100,4 @@ describe('preview', function()
       helpers.delete_buffer(bufnr)
     end)
   end)
-
-  describe('statusline', function()
-    it('returns empty string when idle', function()
-      local bufnr = helpers.create_buffer({})
-      assert.are.equal('', preview.statusline(bufnr))
-      helpers.delete_buffer(bufnr)
-    end)
-  end)
-
-  describe('unnamed buffer guard', function()
-    before_each(function()
-      helpers.reset_config({ typst = true })
-      preview = require('preview')
-    end)
-
-    local function capture_notify(fn)
-      local msg = nil
-      local orig = vim.notify
-      vim.notify = function(m)
-        msg = m
-      end
-      fn()
-      vim.notify = orig
-      return msg
-    end
-
-    it('compile warns on unnamed buffer', function()
-      local bufnr = helpers.create_buffer({}, 'typst')
-      local msg = capture_notify(function()
-        preview.compile(bufnr)
-      end)
-      assert.is_not_nil(msg)
-      assert.is_truthy(msg:find('no file name'))
-      helpers.delete_buffer(bufnr)
-    end)
-
-    it('toggle warns on unnamed buffer', function()
-      local bufnr = helpers.create_buffer({}, 'typst')
-      local msg = capture_notify(function()
-        preview.toggle(bufnr)
-      end)
-      assert.is_not_nil(msg)
-      assert.is_truthy(msg:find('no file name'))
-      helpers.delete_buffer(bufnr)
-    end)
-
-    it('clean warns on unnamed buffer', function()
-      local bufnr = helpers.create_buffer({}, 'typst')
-      local msg = capture_notify(function()
-        preview.clean(bufnr)
-      end)
-      assert.is_not_nil(msg)
-      assert.is_truthy(msg:find('no file name'))
-      helpers.delete_buffer(bufnr)
-    end)
-
-    it('open warns on unnamed buffer', function()
-      local bufnr = helpers.create_buffer({}, 'typst')
-      local msg = capture_notify(function()
-        preview.open(bufnr)
-      end)
-      assert.is_not_nil(msg)
-      assert.is_truthy(msg:find('no file name'))
-      helpers.delete_buffer(bufnr)
-    end)
-  end)
 end)

spec/presets_spec.lua

@@ -21,10 +21,10 @@ describe('presets', function()
       assert.are.same({ 'typst', 'compile' }, presets.typst.cmd)
     end)
 
-    it('returns args with diagnostic format and file path', function()
+    it('returns args with file path', function()
       local args = presets.typst.args(ctx)
       assert.is_table(args)
-      assert.are.same({ '--diagnostic-format', 'short', '/tmp/document.typ' }, args)
+      assert.are.same({ '/tmp/document.typ' }, args)
     end)
 
     it('returns pdf output path', function()
@@ -33,51 +33,9 @@ describe('presets', function()
       assert.are.equal('/tmp/document.pdf', output)
     end)
 
-    it('returns clean command', function()
-      assert.are.same({ 'rm', '-f', '/tmp/document.pdf' }, presets.typst.clean(ctx))
-    end)
-
     it('has open enabled', function()
       assert.is_true(presets.typst.open)
     end)
-
-    it('has reload as a function', function()
-      assert.is_function(presets.typst.reload)
-    end)
-
-    it('reload returns typst watch command', function()
-      local result = presets.typst.reload(ctx)
-      assert.is_table(result)
-      assert.are.equal('typst', result[1])
-      assert.are.equal('watch', result[2])
-      assert.are.equal('--diagnostic-format', result[3])
-      assert.are.equal('short', result[4])
-      assert.are.equal(ctx.file, result[5])
-    end)
-
-    it('parses errors from stderr', function()
-      local stderr = table.concat({
-        'main.typ:5:23: error: unexpected token',
-        'main.typ:12:1: warning: unused variable',
-      }, '\n')
-      local diagnostics = presets.typst.error_parser(stderr, ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(2, #diagnostics)
-      assert.are.equal(4, diagnostics[1].lnum)
-      assert.are.equal(22, diagnostics[1].col)
-      assert.are.equal('unexpected token', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-      assert.is_nil(diagnostics[1].source)
-      assert.are.equal(11, diagnostics[2].lnum)
-      assert.are.equal(0, diagnostics[2].col)
-      assert.are.equal('unused variable', diagnostics[2].message)
-      assert.are.equal(vim.diagnostic.severity.WARN, diagnostics[2].severity)
-    end)
-
-    it('returns empty table for clean stderr', function()
-      local diagnostics = presets.typst.error_parser('', ctx)
-      assert.are.same({}, diagnostics)
-    end)
   end)
 
   describe('latex', function()
@@ -99,13 +57,7 @@ describe('presets', function()
     it('returns args with pdf flag and file path', function()
       local args = presets.latex.args(tex_ctx)
       assert.is_table(args)
-      assert.are.same({
+      assert.are.same({ '-pdf', '-interaction=nonstopmode', '/tmp/document.tex' }, args)
-        '-pdf',
-        '-interaction=nonstopmode',
-        '-synctex=1',
-        '-pdflatex=pdflatex -file-line-error -interaction=nonstopmode %O %S',
-        '/tmp/document.tex',
-      }, args)
     end)
 
     it('returns pdf output path', function()
@@ -123,158 +75,6 @@ describe('presets', function()
     it('has open enabled', function()
       assert.is_true(presets.latex.open)
     end)
-
-    it('parses file-line-error format from output', function()
-      local output = table.concat({
-        './document.tex:10: Undefined control sequence.',
-        'l.10 \\badcommand',
-        'Collected error summary (may duplicate other messages):',
-        "  pdflatex: Command for 'pdflatex' gave return code 256",
-      }, '\n')
-      local diagnostics = presets.latex.error_parser(output, tex_ctx)
-      assert.is_table(diagnostics)
-      assert.is_true(#diagnostics > 0)
-      assert.are.equal(9, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('Undefined control sequence.', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('parses collected error summary', function()
-      local output = table.concat({
-        'Latexmk: Errors, so I did not complete making targets',
-        'Collected error summary (may duplicate other messages):',
-        "  pdflatex: Command for 'pdflatex' gave return code 256",
-      }, '\n')
-      local diagnostics = presets.latex.error_parser(output, tex_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(0, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal(
-        "pdflatex: Command for 'pdflatex' gave return code 256",
-        diagnostics[1].message
-      )
-    end)
-
-    it('returns empty table for clean stderr', function()
-      local diagnostics = presets.latex.error_parser('', tex_ctx)
-      assert.are.same({}, diagnostics)
-    end)
-  end)
-
-  describe('pdflatex', function()
-    local tex_ctx = {
-      bufnr = 1,
-      file = '/tmp/document.tex',
-      root = '/tmp',
-      ft = 'tex',
-    }
-
-    it('has ft', function()
-      assert.are.equal('tex', presets.pdflatex.ft)
-    end)
-
-    it('has cmd', function()
-      assert.are.same({ 'pdflatex' }, presets.pdflatex.cmd)
-    end)
-
-    it('returns args with flags and file path', function()
-      local args = presets.pdflatex.args(tex_ctx)
-      assert.are.same(
-        { '-interaction=nonstopmode', '-file-line-error', '-synctex=1', '/tmp/document.tex' },
-        args
-      )
-    end)
-
-    it('returns pdf output path', function()
-      assert.are.equal('/tmp/document.pdf', presets.pdflatex.output(tex_ctx))
-    end)
-
-    it('has open enabled', function()
-      assert.is_true(presets.pdflatex.open)
-    end)
-
-    it('returns clean command removing pdf and aux files', function()
-      local clean = presets.pdflatex.clean(tex_ctx)
-      assert.are.same({
-        'rm',
-        '-f',
-        '/tmp/document.pdf',
-        '/tmp/document.aux',
-        '/tmp/document.log',
-        '/tmp/document.synctex.gz',
-      }, clean)
-    end)
-
-    it('has no reload', function()
-      assert.is_nil(presets.pdflatex.reload)
-    end)
-
-    it('parses file-line-error format', function()
-      local output = './document.tex:10: Undefined control sequence.'
-      local diagnostics = presets.pdflatex.error_parser(output, tex_ctx)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(9, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('Undefined control sequence.', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('returns empty table for clean output', function()
-      assert.are.same({}, presets.pdflatex.error_parser('', tex_ctx))
-    end)
-  end)
-
-  describe('tectonic', function()
-    local tex_ctx = {
-      bufnr = 1,
-      file = '/tmp/document.tex',
-      root = '/tmp',
-      ft = 'tex',
-    }
-
-    it('has ft', function()
-      assert.are.equal('tex', presets.tectonic.ft)
-    end)
-
-    it('has cmd', function()
-      assert.are.same({ 'tectonic' }, presets.tectonic.cmd)
-    end)
-
-    it('returns args with file path', function()
-      assert.are.same({ '/tmp/document.tex' }, presets.tectonic.args(tex_ctx))
-    end)
-
-    it('returns pdf output path', function()
-      assert.are.equal('/tmp/document.pdf', presets.tectonic.output(tex_ctx))
-    end)
-
-    it('has open enabled', function()
-      assert.is_true(presets.tectonic.open)
-    end)
-
-    it('returns clean command removing pdf', function()
-      assert.are.same({ 'rm', '-f', '/tmp/document.pdf' }, presets.tectonic.clean(tex_ctx))
-    end)
-
-    it('has no reload', function()
-      assert.is_nil(presets.tectonic.reload)
-    end)
-
-    it('parses file-line-error format', function()
-      local output = './document.tex:5: Missing $ inserted.'
-      local diagnostics = presets.tectonic.error_parser(output, tex_ctx)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(4, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('Missing $ inserted.', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('returns empty table for clean output', function()
-      assert.are.same({}, presets.tectonic.error_parser('', tex_ctx))
-    end)
   end)
 
   describe('markdown', function()
@@ -283,7 +83,6 @@ describe('presets', function()
       file = '/tmp/document.md',
       root = '/tmp',
       ft = 'markdown',
-      output = '/tmp/document.html',
     }
 
     it('has ft', function()
@@ -318,51 +117,6 @@ describe('presets', function()
     it('has open enabled', function()
       assert.is_true(presets.markdown.open)
     end)
-
-    it('has reload enabled for SSE', function()
-      assert.is_true(presets.markdown.reload)
-    end)
-
-    it('parses YAML metadata errors with multiline message', function()
-      local output = table.concat({
-        'Error parsing YAML metadata at "/tmp/test.md" (line 1, column 1):',
-        'YAML parse exception at line 1, column 9:',
-        'mapping values are not allowed in this context',
-      }, '\n')
-      local diagnostics = presets.markdown.error_parser(output, md_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(0, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('mapping values are not allowed in this context', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('parses Error at format', function()
-      local output = 'Error at "source" (line 75, column 1): unexpected end of input'
-      local diagnostics = presets.markdown.error_parser(output, md_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(74, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('unexpected end of input', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('parses generic pandoc errors', function()
-      local output = 'pandoc: Could not find data file templates/default.html5'
-      local diagnostics = presets.markdown.error_parser(output, md_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(0, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('Could not find data file templates/default.html5', diagnostics[1].message)
-    end)
-
-    it('returns empty table for clean output', function()
-      local diagnostics = presets.markdown.error_parser('', md_ctx)
-      assert.are.same({}, diagnostics)
-    end)
   end)
 
   describe('github', function()
@@ -371,7 +125,6 @@ describe('presets', function()
       file = '/tmp/document.md',
       root = '/tmp',
       ft = 'markdown',
-      output = '/tmp/document.html',
     }
 
     it('has ft', function()
@@ -426,151 +179,5 @@ describe('presets', function()
     it('has open enabled', function()
       assert.is_true(presets.github.open)
     end)
-
-    it('has reload enabled for SSE', function()
-      assert.is_true(presets.github.reload)
-    end)
-
-    it('parses YAML metadata errors with multiline message', function()
-      local output = table.concat({
-        'Error parsing YAML metadata at "/tmp/test.md" (line 1, column 1):',
-        'YAML parse exception at line 1, column 9:',
-        'mapping values are not allowed in this context',
-      }, '\n')
-      local diagnostics = presets.github.error_parser(output, md_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(0, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('mapping values are not allowed in this context', diagnostics[1].message)
-    end)
-
-    it('parses Error at format', function()
-      local output = 'Error at "document.md" (line 12, column 5): unexpected "}" expecting letter'
-      local diagnostics = presets.github.error_parser(output, md_ctx)
-      assert.is_table(diagnostics)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(11, diagnostics[1].lnum)
-      assert.are.equal(4, diagnostics[1].col)
-      assert.are.equal('unexpected "}" expecting letter', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('returns empty table for clean output', function()
-      local diagnostics = presets.github.error_parser('', md_ctx)
-      assert.are.same({}, diagnostics)
-    end)
-  end)
-
-  describe('asciidoctor', function()
-    local adoc_ctx = {
-      bufnr = 1,
-      file = '/tmp/document.adoc',
-      root = '/tmp',
-      ft = 'asciidoc',
-      output = '/tmp/document.html',
-    }
-
-    it('has ft', function()
-      assert.are.equal('asciidoc', presets.asciidoctor.ft)
-    end)
-
-    it('has cmd', function()
-      assert.are.same({ 'asciidoctor' }, presets.asciidoctor.cmd)
-    end)
-
-    it('returns args with file and output', function()
-      assert.are.same(
-        { '--failure-level', 'ERROR', '/tmp/document.adoc', '-o', '/tmp/document.html' },
-        presets.asciidoctor.args(adoc_ctx)
-      )
-    end)
-
-    it('returns html output path', function()
-      assert.are.equal('/tmp/document.html', presets.asciidoctor.output(adoc_ctx))
-    end)
-
-    it('returns clean command', function()
-      assert.are.same({ 'rm', '-f', '/tmp/document.html' }, presets.asciidoctor.clean(adoc_ctx))
-    end)
-
-    it('has open enabled', function()
-      assert.is_true(presets.asciidoctor.open)
-    end)
-
-    it('has reload enabled for SSE', function()
-      assert.is_true(presets.asciidoctor.reload)
-    end)
-
-    it('parses error messages', function()
-      local output =
-        'asciidoctor: ERROR: document.adoc: line 8: invalid part, must have at least one section'
-      local diagnostics = presets.asciidoctor.error_parser(output, adoc_ctx)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(7, diagnostics[1].lnum)
-      assert.are.equal(0, diagnostics[1].col)
-      assert.are.equal('invalid part, must have at least one section', diagnostics[1].message)
-      assert.are.equal(vim.diagnostic.severity.ERROR, diagnostics[1].severity)
-    end)
-
-    it('parses warning messages', function()
-      local output = 'asciidoctor: WARNING: document.adoc: line 52: section title out of sequence'
-      local diagnostics = presets.asciidoctor.error_parser(output, adoc_ctx)
-      assert.are.equal(1, #diagnostics)
-      assert.are.equal(51, diagnostics[1].lnum)
-      assert.are.equal(vim.diagnostic.severity.WARN, diagnostics[1].severity)
-    end)
-
-    it('returns empty table for clean output', function()
-      assert.are.same({}, presets.asciidoctor.error_parser('', adoc_ctx))
-    end)
-  end)
-
-  describe('quarto', function()
-    local qmd_ctx = {
-      bufnr = 1,
-      file = '/tmp/document.qmd',
-      root = '/tmp',
-      ft = 'quarto',
-      output = '/tmp/document.html',
-    }
-
-    it('has ft', function()
-      assert.are.equal('quarto', presets.quarto.ft)
-    end)
-
-    it('has cmd', function()
-      assert.are.same({ 'quarto' }, presets.quarto.cmd)
-    end)
-
-    it('returns args with render subcommand and html format', function()
-      assert.are.same(
-        { 'render', '/tmp/document.qmd', '--to', 'html', '--embed-resources' },
-        presets.quarto.args(qmd_ctx)
-      )
-    end)
-
-    it('returns html output path', function()
-      assert.are.equal('/tmp/document.html', presets.quarto.output(qmd_ctx))
-    end)
-
-    it('returns clean command removing html and _files directory', function()
-      assert.are.same(
-        { 'rm', '-rf', '/tmp/document.html', '/tmp/document_files' },
-        presets.quarto.clean(qmd_ctx)
-      )
-    end)
-
-    it('has open enabled', function()
-      assert.is_true(presets.quarto.open)
-    end)
-
-    it('has reload enabled for SSE', function()
-      assert.is_true(presets.quarto.reload)
-    end)
-
-    it('has no error_parser', function()
-      assert.is_nil(presets.quarto.error_parser)
-    end)
   end)
 end)

spec/reload_spec.lua

@@ -1,58 +0,0 @@
-describe('reload', function()
-  local reload
-
-  before_each(function()
-    package.loaded['preview.reload'] = nil
-    reload = require('preview.reload')
-  end)
-
-  after_each(function()
-    reload.stop()
-  end)
-
-  describe('inject', function()
-    it('injects script before </body>', function()
-      local path = os.tmpname()
-      local f = assert(io.open(path, 'w'))
-      f:write('<html><body><p>hello</p></body></html>')
-      f:close()
-
-      reload.inject(path)
-
-      local fr = assert(io.open(path, 'r'))
-      local content = fr:read('*a')
-      fr:close()
-      os.remove(path)
-
-      assert.is_truthy(content:find('EventSource', 1, true))
-      local script_pos = content:find('EventSource', 1, true)
-      local body_pos = content:find('</body>', 1, true)
-      assert.is_truthy(body_pos)
-      assert.is_true(script_pos < body_pos)
-    end)
-
-    it('appends script when no </body>', function()
-      local path = os.tmpname()
-      local f = assert(io.open(path, 'w'))
-      f:write('<html><p>hello</p></html>')
-      f:close()
-
-      reload.inject(path)
-
-      local fr = assert(io.open(path, 'r'))
-      local content = fr:read('*a')
-      fr:close()
-      os.remove(path)
-
-      assert.is_truthy(content:find('EventSource', 1, true))
-    end)
-  end)
-
-  describe('broadcast', function()
-    it('does not error with no clients', function()
-      assert.has_no.errors(function()
-        reload.broadcast()
-      end)
-    end)
-  end)
-end)