diff --git a/runtime/doc/zip.txt b/runtime/doc/zip.txt
index caf20cc236..4dae097e68 100644
--- a/runtime/doc/zip.txt
+++ b/runtime/doc/zip.txt
@@ -22,8 +22,12 @@ Editing a zip-like file opens a read-only listing. Directory entries can be
 opened to browse that level of the archive. File entries open as read-only
 `zipfile://{archive}::{path}` buffers.
 
-Mappings are the standard |dir-buffer-mappings|. At the archive root, - opens
-the containing filesystem directory.
+Mappings are the standard |dir-buffer-mappings|, plus:
+
+• x extracts the entry under the cursor into the current directory, discarding
+  its path inside the archive. It never overwrites an existing file.
+
+At the archive root, - opens the containing filesystem directory.
 
 Recognized extensions include zip, jar, apk, epub, Office and OpenDocument
 formats, whl, xpi, pkpass, and cbz.
@@ -36,10 +40,10 @@ Remote zip URLs are downloaded by |vim.net| and opened in the browser.
 
 LIMITATIONS                                                *zip-limitations*
 
-Archive entries cannot be updated or extracted. Remote archives are not
-refetched on reload, and there is no PowerShell fallback, no custom backend
-command, and no support for the legacy `g:zip_*` variables. Use |old-zip|
-when those features are required.
+Archive entries cannot be updated. Remote archives are not refetched on
+reload, and there is no PowerShell fallback, no custom backend command, and no
+support for the legacy `g:zip_*` variables. Use |old-zip| when those features
+are required.
 
 ==============================================================================
 Legacy plugin: zip                                                   *old-zip*
diff --git a/runtime/lua/nvim/zip.lua b/runtime/lua/nvim/zip.lua
index 7dd55b90dc..39018d517e 100644
--- a/runtime/lua/nvim/zip.lua
+++ b/runtime/lua/nvim/zip.lua
@@ -13,12 +13,25 @@ local function unzip()
   return command
 end
 
---- Escape a path passed to Info-ZIP, which expands glob patterns even without a shell.
+--- Escape a path so that Info-ZIP matches it literally.
+---
+--- Info-ZIP matches `*`, `?`, and `[]` in a member selector itself, so this is not shell
+--- quoting: passing argv already avoids the shell. For example, unescaped `a[a].txt`
+--- silently reads `aa.txt`, and `a?.txt` matches every four-character name. A literal `[`
+--- cannot be backslash-escaped, so it is wrapped in a class instead, as is a leading `-`,
+--- which would otherwise parse as an option.
 --- https://github.com/neovim/neovim/blob/7ba955fe079d4aa2554fea8e7235651fafd40efb/runtime/autoload/zip.vim#L316-L339
 ---@param value string
 ---@return string
 local function literal_pattern(value)
-  return (value:gsub('\\', '\\\\'):gsub('%?', '\\?'):gsub('%*', '\\*'):gsub('%[', '[[]'))
+  return (
+    value
+      :gsub('\\', '\\\\')
+      :gsub('%?', '\\?')
+      :gsub('%*', '\\*')
+      :gsub('%[', '[[]')
+      :gsub('^%-', '[-]')
+  )
 end
 
 ---@param source string
@@ -38,6 +51,9 @@ local function list_archive(source)
   end
   local result = system:wait()
   if result.code ~= 0 then
+    if vim.trim(result.stdout or '') == 'Empty zipfile.' then
+      return {}
+    end
     return nil, vim.trim(result.stderr or ''), true
   end
   return vim.split(result.stdout or '', '\n', { plain = true, trimempty = true })
@@ -388,9 +404,64 @@ function M.open_parent(buf, name)
   require('nvim.dir.fs').open_parent_path(state.source)
 end
 
+--- Extract the entry under the cursor into the current directory.
+--- `-j` discards the archive path, so the destination is always a name in the
+--- current directory and cannot be redirected by a hostile entry.
+function M._extract()
+  local buf = api.nvim_get_current_buf()
+  local state = get_state(buf)
+  if not state then
+    return
+  end
+  local command, command_err = unzip()
+  if not command then
+    notify('zip', command_err or 'unzip executable not found')
+    return
+  end
+  local line = api.nvim_get_current_line()
+  if line == '' then
+    return
+  end
+  if line:sub(-1) == '/' then
+    notify('zip', 'please specify a file, not a directory')
+    return
+  end
+  local path = (state.prefix or '') .. line
+  local directory = vim.fn.getcwd()
+  local target = vim.fs.joinpath(directory, vim.fs.basename(path))
+  if uv.fs_stat(target) then
+    notify('zip', ('%s already exists, not overwriting'):format(target))
+    return
+  end
+  local ok, system = pcall(vim.system, {
+    command,
+    '-o',
+    '-j',
+    '--',
+    literal_pattern(state.source),
+    literal_pattern(path),
+  }, { cwd = directory, text = true })
+  if not ok then
+    notify('zip', tostring(system))
+    return
+  end
+  local result = system:wait()
+  if not uv.fs_stat(target) then
+    notify(
+      'zip',
+      ('unable to extract %s from %s: %s'):format(path, state.source, vim.trim(result.stderr or ''))
+    )
+    return
+  end
+  notify('zip', ('extracted %s'):format(target), vim.log.levels.INFO)
+end
+
 ---@param buf integer
 function M.init(buf)
   api.nvim_set_option_value('filetype', 'zip', { buf = buf })
+  if vim.fn.hasmapto('<Plug>(nvim-zip-extract)', 'n') == 0 then
+    vim.keymap.set('n', 'x', '<Plug>(nvim-zip-extract)', { buffer = buf, silent = true })
+  end
   api.nvim_buf_call(buf, function()
     vim.wo.wrap = false
   end)
diff --git a/runtime/plugin/zip.lua b/runtime/plugin/zip.lua
index b43de878e2..8ba5aaa6c6 100644
--- a/runtime/plugin/zip.lua
+++ b/runtime/plugin/zip.lua
@@ -73,6 +73,10 @@ local archive_patterns = {}
 for _, extension in ipairs(extensions) do
   archive_patterns[#archive_patterns + 1] = ('*.%s'):format(extension)
 end
+vim.keymap.set('n', '<Plug>(nvim-zip-extract)', function()
+  require('nvim.zip')._extract()
+end, { silent = true, desc = 'Extract zip archive entry' })
+
 local group = api.nvim_create_augroup('nvim.zip', { clear = true })
 
 ---@return boolean
diff --git a/test/functional/fixtures/zip/browser.zip b/test/functional/fixtures/zip/browser.zip
index 24e2716422..58288753e6 100644
Binary files a/test/functional/fixtures/zip/browser.zip and b/test/functional/fixtures/zip/browser.zip differ
diff --git a/test/functional/plugin/zip_spec.lua b/test/functional/plugin/zip_spec.lua
index 7d5497710a..407f0766e3 100644
--- a/test/functional/plugin/zip_spec.lua
+++ b/test/functional/plugin/zip_spec.lua
@@ -25,10 +25,6 @@ local function clear_zip()
   n.clear({ args = { '--clean' } })
 end
 
-local function copy_fixture(source, target)
-  assert(vim.uv.fs_copyfile(source, target))
-end
-
 local function line_of(text)
   for i, line in ipairs(lines()) do
     if line == text then
@@ -41,6 +37,21 @@ end
 describe('nvim.zip', function()
   local root
 
+  --- Copy an archive into the test directory and return its path.
+  local function stage(source_dir, source, as)
+    local target = vim.fs.joinpath(root, as or source)
+    assert(vim.uv.fs_copyfile(vim.fs.joinpath(source_dir, source), target))
+    return target
+  end
+
+  --- Stage the browsing fixture, restart, and open it.
+  local function browse(as)
+    local archive = stage(fixtures, 'browser.zip', as)
+    clear_zip()
+    edit(archive)
+    return archive
+  end
+
   before_each(function()
     t.skip(vim.fn.executable('unzip') == 0, 'unzip not available')
     root = vim.fs.normalize(t.tmpname(false) .. ' space%#')
@@ -51,302 +62,420 @@ describe('nvim.zip', function()
     n.rmdir(root)
   end)
 
-  it('uses zip.lua by default', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
+  describe('activation', function()
+    it('uses zip.lua by default', function()
+      browse()
 
-    edit(archive)
+      eq('folder/', lines()[1])
+      eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
+      eq(false, exec_lua('return vim.g.loaded_zipPlugin ~= nil'))
+    end)
 
-    eq('folder/', lines()[1])
-    eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
-    eq(false, exec_lua('return vim.g.loaded_zipPlugin ~= nil'))
-  end)
+    it('defers to zipPlugin.vim loaded before startup plugins', function()
+      local archive = stage(old_samples, 'test.zip', 'legacy.zip')
+      n.clear({ args = { '--clean', '--cmd', 'packadd old-zip' } })
 
-  it('defers to zipPlugin.vim loaded before startup plugins', function()
-    local archive = vim.fs.joinpath(root, 'legacy.zip')
-    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), archive)
-    n.clear({ args = { '--clean', '--cmd', 'packadd old-zip' } })
+      edit(archive)
 
-    edit(archive)
+      eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
+      eq(0, fn.exists('#nvim.zip'))
+      eq(false, exec_lua('return vim.g.loaded_nvim_zip_plugin ~= nil'))
+    end)
 
-    eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
-    eq(0, fn.exists('#nvim.zip'))
-    eq(false, exec_lua('return vim.g.loaded_nvim_zip_plugin ~= nil'))
-  end)
+    it('yields to zipPlugin.vim loaded after startup', function()
+      local archive = stage(old_samples, 'test.zip', 'legacy.zip')
+      clear_zip()
+      exec_lua([[vim.cmd.packadd('old-zip')]])
 
-  it('yields to zipPlugin.vim loaded after startup', function()
-    local archive = vim.fs.joinpath(root, 'legacy.zip')
-    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), archive)
-    clear_zip()
-    exec_lua([[vim.cmd.packadd('old-zip')]])
+      edit(archive)
 
-    edit(archive)
+      eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
+      eq(1, fn.exists('#nvim.zip'))
+      eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
+    end)
 
-    eq(true, lines()[1]:find('" zip.vim version', 1, true) ~= nil)
-    eq(1, fn.exists('#nvim.zip'))
-    eq(true, exec_lua('return vim.g.loaded_nvim_zip_plugin == true'))
-  end)
+    it('can be disabled', function()
+      local archive = stage(fixtures, 'browser.zip')
+      n.clear({
+        args = { '--clean', '--cmd', 'let g:loaded_nvim_zip_plugin = 1' },
+      })
 
-  it('can be disabled', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    n.clear({
-      args = { '--clean', '--cmd', 'let g:loaded_nvim_zip_plugin = 1' },
-    })
+      edit(archive)
 
-    edit(archive)
+      eq(0, fn.exists('#nvim.zip'))
+      eq('', api.nvim_get_option_value('filetype', { buf = 0 }))
+    end)
 
-    eq(0, fn.exists('#nvim.zip'))
-    eq('', api.nvim_get_option_value('filetype', { buf = 0 }))
-  end)
+    it('can source zip.lua repeatedly', function()
+      clear_zip()
 
-  it('can source zip.lua repeatedly', function()
-    clear_zip()
+      -- Re-sourcing must reuse the augroup rather than stack duplicate autocmds.
+      eq(
+        2,
+        exec_lua(function()
+          vim.cmd.runtime('plugin/zip.lua')
+          vim.cmd.runtime('plugin/zip.lua')
+          local ids = {}
+          for _, autocmd in ipairs(vim.api.nvim_get_autocmds({ group = 'nvim.zip' })) do
+            ids[autocmd.id] = true
+          end
+          return vim.tbl_count(ids)
+        end)
+      )
+    end)
 
-    eq(
-      2,
-      exec_lua(function()
-        vim.cmd.runtime('plugin/zip.lua')
-        vim.cmd.runtime('plugin/zip.lua')
-        local ids = {}
-        for _, autocmd in ipairs(vim.api.nvim_get_autocmds({ group = 'nvim.zip' })) do
-          ids[autocmd.id] = true
-        end
-        return vim.tbl_count(ids)
-      end)
-    )
-  end)
+    it('reports an unavailable backend without claiming the buffer', function()
+      local archive = stage(fixtures, 'browser.zip')
+      clear_zip()
+      exec_lua([[vim.env.PATH = '']])
 
-  it('opens zip-compatible file types', function()
-    local archive = vim.fs.joinpath(root, 'browser.jar')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(archive)
-
-    eq('folder/', lines()[1])
-    eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
-  end)
-
-  it('browses directories and opens entries', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(archive)
-
-    eq(
-      { 'folder/', 'inner.zip', '../escape.txt', '/absolute.txt', 'crlf.txt', 'noeol.txt' },
-      lines()
-    )
-    eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
-    eq(true, exec_capture('syntax list zipDirectory'):find('zipDirectory', 1, true) ~= nil)
-
-    feed('<CR>')
-    poke_eventloop()
-    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
-
-    feed('<CR>')
-    poke_eventloop()
-    eq({ 'file.txt' }, lines())
-
-    feed('-')
-    poke_eventloop()
-    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
-    eq('nested/', api.nvim_get_current_line())
-
-    api.nvim_win_set_cursor(0, { 2, 0 })
-    feed('<CR>')
-    poke_eventloop()
-    eq({ 'root text' }, lines())
-    eq('nowrite', api.nvim_get_option_value('buftype', { buf = 0 }))
-    eq(true, api.nvim_get_option_value('readonly', { buf = 0 }))
-    eq(false, api.nvim_get_option_value('modifiable', { buf = 0 }))
-    eq(false, api.nvim_get_option_value('swapfile', { buf = 0 }))
-  end)
-
-  it('opens the containing directory from the archive root', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(archive)
-    feed('-')
-    poke_eventloop()
-
-    eq(root, vim.fs.normalize(api.nvim_buf_get_name(0)))
-    eq('browser.zip', api.nvim_get_current_line())
-    eq('directory', api.nvim_get_option_value('filetype', { buf = 0 }))
-  end)
-
-  it('opens entries at quickfix locations', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-    local uri = ('zipfile://%s::crlf.txt'):format(archive)
-    fn.setqflist({}, 'r', {
-      items = { { filename = uri, lnum = 2, col = 1 } },
-    })
-
-    api.nvim_cmd({ cmd = 'cfirst' }, {})
-
-    eq(uri, api.nvim_buf_get_name(0))
-    eq({ 2, 0 }, api.nvim_win_get_cursor(0))
-    eq('text', api.nvim_get_option_value('filetype', { buf = 0 }))
-  end)
-
-  it('does not reinterpret an entry ending in .zip as an archive', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(archive)
-    api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
-    feed('<CR>')
-    poke_eventloop()
-
-    eq({ 'nested payload' }, lines())
-    eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
-  end)
-
-  it('preserves normal file reading details for entries', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(('zipfile://%s::crlf.txt'):format(archive))
-    eq({ 'one', 'two' }, lines())
-    eq('dos', api.nvim_get_option_value('fileformat', { buf = 0 }))
-    eq(true, api.nvim_get_option_value('endofline', { buf = 0 }))
-
-    edit(('zipfile://%s::noeol.txt'):format(archive))
-    eq({ 'no final newline' }, lines())
-    eq(false, api.nvim_get_option_value('endofline', { buf = 0 }))
-  end)
-
-  it('integrates Java sources with zip.lua and zipPlugin.vim', function()
-    local archive = vim.fs.joinpath(root, 'source.jar')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-
-    for _, legacy in ipairs({ false, true }) do
-      if legacy then
-        n.clear({
-          args = { '--clean', '--cmd', 'packadd old-zip' },
-        })
-      else
-        clear_zip()
-      end
-      exec_lua('vim.g.ftplugin_java_source_path = ...', archive)
-      api.nvim_buf_set_name(0, vim.fs.joinpath(root, 'Test.java'))
-      api.nvim_buf_set_lines(0, 0, -1, false, { 'folder.root' })
-      api.nvim_cmd({ cmd = 'setfiletype', args = { 'java' } }, {})
-      api.nvim_cmd({ cmd = 'runtime', args = { 'ftplugin/java.vim' } }, {})
-
-      feed('gf')
+      edit(archive)
       poke_eventloop()
 
-      eq(('zipfile://%s::folder/root.java'):format(archive), api.nvim_buf_get_name(0))
-      eq({ 'class root {}' }, lines())
-      eq('java', api.nvim_get_option_value('filetype', { buf = 0 }))
+      eq(true, exec_capture('messages'):find('unzip executable not found', 1, true) ~= nil)
+      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
+    end)
+  end)
+
+  describe('browsing', function()
+    it('opens zip-compatible file types', function()
+      browse('browser.jar')
+
+      eq('folder/', lines()[1])
+      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
+    end)
+
+    it('browses directories and opens entries', function()
+      browse()
+
+      eq({
+        'folder/',
+        'inner.zip',
+        '../escape.txt',
+        '/absolute.txt',
+        'crlf.txt',
+        'noeol.txt',
+        'names/',
+      }, lines())
+      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
+      eq(true, exec_capture('syntax list zipDirectory'):find('zipDirectory', 1, true) ~= nil)
+
+      feed('<CR>')
+      poke_eventloop()
+      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
+
+      feed('<CR>')
+      poke_eventloop()
+      eq({ 'file.txt' }, lines())
+
+      feed('-')
+      poke_eventloop()
+      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
+      eq('nested/', api.nvim_get_current_line())
+
+      api.nvim_win_set_cursor(0, { 2, 0 })
+      feed('<CR>')
+      poke_eventloop()
+      eq({ 'root text' }, lines())
+      eq('nowrite', api.nvim_get_option_value('buftype', { buf = 0 }))
+      eq(true, api.nvim_get_option_value('readonly', { buf = 0 }))
+      eq(false, api.nvim_get_option_value('modifiable', { buf = 0 }))
+      eq(false, api.nvim_get_option_value('swapfile', { buf = 0 }))
+    end)
+
+    it('opens the containing directory from the archive root', function()
+      browse()
+      feed('-')
+      poke_eventloop()
+
+      eq(root, vim.fs.normalize(api.nvim_buf_get_name(0)))
+      eq('browser.zip', api.nvim_get_current_line())
+      eq('directory', api.nvim_get_option_value('filetype', { buf = 0 }))
+    end)
+
+    it('opens entries at quickfix locations', function()
+      local archive = stage(fixtures, 'browser.zip')
+      clear_zip()
+      local uri = ('zipfile://%s::crlf.txt'):format(archive)
+      fn.setqflist({}, 'r', { items = { { filename = uri, lnum = 2, col = 1 } } })
+
+      api.nvim_cmd({ cmd = 'cfirst' }, {})
+
+      eq(uri, api.nvim_buf_get_name(0))
+      eq({ 2, 0 }, api.nvim_win_get_cursor(0))
+      eq('text', api.nvim_get_option_value('filetype', { buf = 0 }))
+    end)
+
+    it('does not reinterpret an entry ending in .zip as an archive', function()
+      browse()
+      api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
+      feed('<CR>')
+      poke_eventloop()
+
+      eq({ 'nested payload' }, lines())
+      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
+    end)
+
+    it('preserves normal file reading details for entries', function()
+      local archive = stage(fixtures, 'browser.zip')
+      clear_zip()
+
+      edit(('zipfile://%s::crlf.txt'):format(archive))
+      eq({ 'one', 'two' }, lines())
+      eq('dos', api.nvim_get_option_value('fileformat', { buf = 0 }))
+      eq(true, api.nvim_get_option_value('endofline', { buf = 0 }))
+
+      edit(('zipfile://%s::noeol.txt'):format(archive))
+      eq({ 'no final newline' }, lines())
+      eq(false, api.nvim_get_option_value('endofline', { buf = 0 }))
+    end)
+
+    it('keeps suspicious entry paths visible and readable', function()
+      browse()
+      api.nvim_win_set_cursor(0, { line_of('../escape.txt'), 0 })
+      feed('<CR>')
+      poke_eventloop()
+
+      eq({ 'escape payload' }, lines())
+    end)
+
+    it('opens non-zip files normally', function()
+      local archive = vim.fs.joinpath(root, 'plain.zip')
+      t.write_file(archive, 'plain text', true)
+      clear_zip()
+
+      edit(archive)
+
+      eq({ 'plain text' }, lines())
+      eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
+    end)
+
+    it('lists a valid empty archive as empty', function()
+      local archive = vim.fs.joinpath(root, 'empty.zip')
+      local file = assert(io.open(archive, 'wb'))
+      -- An end-of-central-directory record with no entries: a valid, empty archive.
+      file:write('PK\5\6' .. string.rep('\0', 18))
+      file:close()
+      clear_zip()
+
+      edit(archive)
+
+      eq({ '' }, lines())
+      eq('zip', api.nvim_get_option_value('filetype', { buf = 0 }))
+      eq(true, exec_lua('return vim.b.nvim_zip ~= nil'))
+    end)
+
+    it('keeps the current level when reload fails', function()
+      local archive = browse()
+      feed('<CR>')
+      poke_eventloop()
+      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
+
+      assert(os.remove(archive))
+      feed('R')
+      poke_eventloop()
+      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
+
+      stage(fixtures, 'browser.zip')
+      feed('R')
+      poke_eventloop()
+      eq({ 'nested/', 'root.txt', 'root.java' }, lines())
+    end)
+
+    it('integrates Java sources with zip.lua and zipPlugin.vim', function()
+      local archive = stage(fixtures, 'browser.zip', 'source.jar')
+
+      for _, legacy in ipairs({ false, true }) do
+        if legacy then
+          n.clear({ args = { '--clean', '--cmd', 'packadd old-zip' } })
+        else
+          clear_zip()
+        end
+        exec_lua('vim.g.ftplugin_java_source_path = ...', archive)
+        api.nvim_buf_set_name(0, vim.fs.joinpath(root, 'Test.java'))
+        api.nvim_buf_set_lines(0, 0, -1, false, { 'folder.root' })
+        api.nvim_cmd({ cmd = 'setfiletype', args = { 'java' } }, {})
+        api.nvim_cmd({ cmd = 'runtime', args = { 'ftplugin/java.vim' } }, {})
+
+        feed('gf')
+        poke_eventloop()
+
+        eq(('zipfile://%s::folder/root.java'):format(archive), api.nvim_buf_get_name(0))
+        eq({ 'class root {}' }, lines())
+        eq('java', api.nvim_get_option_value('filetype', { buf = 0 }))
+      end
+    end)
+  end)
+
+  -- Info-ZIP expands globs itself and reads leading dashes as options, so archive
+  -- and entry paths must always reach it as literal text.
+  describe('backend arguments', function()
+    it('reads entry selectors literally', function()
+      t.skip(t.is_os('win'), 'N/A: archive contains backslashes in entry paths')
+      local archive = stage(old_samples, 'testa.zip', 'special.zip')
+      clear_zip()
+
+      local cases = {
+        { 'zipglob/a[a].txt', 'a test file with []' },
+        { 'zipglob/a*.txt', 'a test file with a*' },
+        { 'zipglob/a?.txt', 'a test file with a?' },
+        { [[zipglob/a\.txt]], [[a test file with a\]] },
+        { [[zipglob/a\\.txt]], [[a test file with a double \]] },
+      }
+      for _, case in ipairs(cases) do
+        edit(('zipfile://%s::%s'):format(archive, case[1]))
+        eq({ case[2] }, lines())
+      end
+    end)
+
+    it('keeps a leading dash in a path from becoming a backend option', function()
+      local archive = stage(old_samples, 'poc.zip')
+      clear_zip()
+
+      edit(archive)
+      eq({ '-d/', 'pwned' }, lines())
+
+      edit(('zipfile://%s::-d/tmp'):format(archive))
+      eq({ '' }, lines())
+    end)
+
+    it('treats archive glob characters literally', function()
+      t.skip(t.is_os('win'), 'N/A: Windows filenames cannot contain these characters')
+      local archive = stage(fixtures, 'browser.zip', 'archive::[*?].zip')
+      -- Would be matched instead of the archive above if the name were globbed.
+      stage(old_samples, 'test.zip', 'archivex.zip')
+      clear_zip()
+
+      edit(archive)
+
+      eq('folder/', lines()[1])
+      api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
+      feed('<CR>')
+      poke_eventloop()
+      eq({ 'nested payload' }, lines())
+
+      local uri = ('zipfile://%s::crlf.txt'):format(archive)
+      edit(uri)
+      eq(uri, api.nvim_buf_get_name(0))
+      eq({ 'one', 'two' }, lines())
+    end)
+
+    it('lists and opens entries with difficult names', function()
+      t.skip(t.is_os('win'), 'N/A: Windows filenames cannot contain these characters')
+      local archive = browse()
+
+      -- "star*" and "-dash" are the glob and option cases; the rest are shell
+      -- metacharacters that must survive an argv-based backend untouched.
+      local names = {
+        'space name.txt',
+        'two  spaces.txt',
+        ' leading.txt',
+        'trailing .txt',
+        [[back\slash.txt]],
+        [[single'quote.txt]],
+        'double"quote.txt',
+        'dollar$name.txt',
+        'backtick`name.txt',
+        'semi;name.txt',
+        'pipe|name.txt',
+        'amp&name.txt',
+        'paren(name).txt',
+        'bang!name.txt',
+        'hash#name.txt',
+        'percent%name.txt',
+        'star*.txt',
+        'question?.txt',
+        '[bracket].txt',
+        '-dash.txt',
+      }
+
+      api.nvim_win_set_cursor(0, { line_of('names/'), 0 })
+      feed('<CR>')
+      poke_eventloop()
+      eq(names, lines())
+
+      api.nvim_win_set_cursor(0, { line_of('star*.txt'), 0 })
+      feed('<CR>')
+      poke_eventloop()
+      eq(('zipfile://%s::names/star*.txt'):format(archive), api.nvim_buf_get_name(0))
+      eq({ 'content of star*.txt' }, lines())
+
+      for _, name in ipairs(names) do
+        edit(('zipfile://%s::names/%s'):format(archive, name))
+        eq({ 'content of ' .. name }, lines())
+      end
+    end)
+  end)
+
+  describe('extract', function()
+    --- Stage an archive, restart with the cwd inside the test directory, and open it.
+    local function open_in_cwd(source_dir, source)
+      local archive = stage(source_dir, source)
+      clear_zip()
+      api.nvim_set_current_dir(root)
+      edit(archive)
+      return archive
     end
-  end)
 
-  it('reads entry selectors literally', function()
-    t.skip(t.is_os('win'), 'N/A: archive contains backslashes in entry paths')
-    local archive = vim.fs.joinpath(root, 'special.zip')
-    copy_fixture(vim.fs.joinpath(old_samples, 'testa.zip'), archive)
-    clear_zip()
+    it('extracts the entry under the cursor into the current directory', function()
+      open_in_cwd(fixtures, 'browser.zip')
+      feed('<CR>')
+      poke_eventloop()
+      api.nvim_win_set_cursor(0, { line_of('root.java'), 0 })
+      feed('x')
+      poke_eventloop()
 
-    local cases = {
-      { 'zipglob/a[a].txt', 'a test file with []' },
-      { 'zipglob/a*.txt', 'a test file with a*' },
-      { 'zipglob/a?.txt', 'a test file with a?' },
-      { [[zipglob/a\.txt]], [[a test file with a\]] },
-      { [[zipglob/a\\.txt]], [[a test file with a double \]] },
-    }
-    for _, case in ipairs(cases) do
-      edit(('zipfile://%s::%s'):format(archive, case[1]))
-      eq({ case[2] }, lines())
-    end
-  end)
+      eq('class root {}\n', t.read_file(vim.fs.joinpath(root, 'root.java')))
+    end)
 
-  it('treats archive glob characters literally', function()
-    t.skip(t.is_os('win'), 'N/A: Windows filenames cannot contain these characters')
-    local archive = vim.fs.joinpath(root, 'archive::[*?].zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    copy_fixture(vim.fs.joinpath(old_samples, 'test.zip'), vim.fs.joinpath(root, 'archivex.zip'))
-    clear_zip()
+    it('refuses to extract a directory', function()
+      open_in_cwd(fixtures, 'browser.zip')
+      api.nvim_win_set_cursor(0, { line_of('folder/'), 0 })
+      feed('x')
+      poke_eventloop()
 
-    edit(archive)
+      eq(true, exec_capture('messages'):find('not a directory', 1, true) ~= nil)
+      eq(nil, vim.uv.fs_stat(vim.fs.joinpath(root, 'folder')))
+    end)
 
-    eq('folder/', lines()[1])
-    api.nvim_win_set_cursor(0, { line_of('inner.zip'), 0 })
-    feed('<CR>')
-    poke_eventloop()
-    eq({ 'nested payload' }, lines())
+    it('refuses to overwrite an existing file when extracting', function()
+      local target = vim.fs.joinpath(root, 'root.java')
+      stage(fixtures, 'browser.zip')
+      t.write_file(target, 'untouched', true)
+      clear_zip()
+      api.nvim_set_current_dir(root)
 
-    local uri = ('zipfile://%s::crlf.txt'):format(archive)
-    edit(uri)
-    eq(uri, api.nvim_buf_get_name(0))
-    eq({ 'one', 'two' }, lines())
-  end)
+      edit(vim.fs.joinpath(root, 'browser.zip'))
+      feed('<CR>')
+      poke_eventloop()
+      api.nvim_win_set_cursor(0, { line_of('root.java'), 0 })
+      feed('x')
+      poke_eventloop()
 
-  it('keeps suspicious entry paths visible and readable', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
+      eq(true, exec_capture('messages'):find('already exists', 1, true) ~= nil)
+      eq('untouched', t.read_file(target))
+    end)
 
-    edit(archive)
-    api.nvim_win_set_cursor(0, { line_of('../escape.txt'), 0 })
-    feed('<CR>')
-    poke_eventloop()
+    it('extracts suspicious entries without escaping the current directory', function()
+      open_in_cwd(old_samples, 'evil.zip')
 
-    eq({ 'escape payload' }, lines())
-  end)
+      eq({
+        '../../../../etc/ax-pwn',
+        'a/../../../../../../../../../../../../../../../../../../tmp/foobar',
+        '/tmp/vim_zip/a/b/payload.txt',
+      }, lines())
 
-  it('opens non-zip files normally', function()
-    local archive = vim.fs.joinpath(root, 'plain.zip')
-    t.write_file(archive, 'plain text', true)
-    clear_zip()
+      for _, entry in ipairs(lines()) do
+        api.nvim_win_set_cursor(0, { line_of(entry), 0 })
+        feed('x')
+        poke_eventloop()
+      end
 
-    edit(archive)
-
-    eq({ 'plain text' }, lines())
-    eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
-  end)
-
-  it('keeps the current level when reload fails', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-
-    edit(archive)
-    feed('<CR>')
-    poke_eventloop()
-    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
-
-    assert(os.remove(archive))
-    feed('R')
-    poke_eventloop()
-    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
-
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    feed('R')
-    poke_eventloop()
-    eq({ 'nested/', 'root.txt', 'root.java' }, lines())
-  end)
-
-  it('reports an unavailable backend without claiming the buffer', function()
-    local archive = vim.fs.joinpath(root, 'browser.zip')
-    copy_fixture(vim.fs.joinpath(fixtures, 'browser.zip'), archive)
-    clear_zip()
-    exec_lua([[vim.env.PATH = '']])
-
-    edit(archive)
-    poke_eventloop()
-
-    eq(true, exec_capture('messages'):find('unzip executable not found', 1, true) ~= nil)
-    eq(false, exec_lua('return vim.b.nvim_dir ~= nil'))
+      -- Each lands flat in the cwd, never at the path the entry asked for.
+      for _, name in ipairs({ 'ax-pwn', 'foobar', 'payload.txt' }) do
+        eq(true, vim.uv.fs_stat(vim.fs.joinpath(root, name)) ~= nil)
+      end
+      eq(nil, vim.uv.fs_stat(vim.fs.joinpath(root, '..', 'ax-pwn')))
+    end)
   end)
 end)