@antora/content-aggregator 3.0.0-alpha.6 → 3.0.0-beta.1

package/lib/aggregate-content.js

@@ -1,19 +1,24 @@
 'use strict'
 
+if (!Promise.allSettled) require('./promise-all-settled-polyfill')
+
 const camelCaseKeys = require('camelcase-keys')
 const { createHash } = require('crypto')
+const createHttpPlugin = require('./git-plugin-http')
+const decodeUint8Array = require('./decode-uint8-array')
 const EventEmitter = require('events')
 const expandPath = require('@antora/expand-path-helper')
 const File = require('./file')
+const filterRefs = require('./filter-refs')
 const flattenDeep = require('./flatten-deep')
 const fs = require('fs')
 const { promises: fsp } = fs
 const getCacheDir = require('cache-directory')
 const GitCredentialManagerStore = require('./git-credential-manager-store')
-const git = require('isomorphic-git')
-const invariably = { false: () => false, void: () => {}, emptyArray: () => [] }
+const git = require('./git')
+const { NotFoundError, ObjectTypeError, UnknownTransportError, UrlParseError } = git.Errors
+const invariably = { true: () => true, false: () => false, void: () => undefined, emptyArray: () => [] }
 const { makeRe: makePicomatchRx } = require('picomatch')
-const matcher = require('matcher')
 const MultiProgress = require('multi-progress')
 const ospath = require('path')
 const { posix: path } = ospath
@@ -21,18 +26,21 @@ const posixify = ospath.sep === '\\' ? (p) => p.replace(/\\/g, '/') : undefined
 const { fs: resolvePathGlobsFs, git: resolvePathGlobsGit } = require('./resolve-path-globs')
 const { Transform } = require('stream')
 const map = (transform, flush = undefined) => new Transform({ objectMode: true, transform, flush })
+const userRequire = require('@antora/user-require-helper')
 const vfs = require('vinyl-fs')
 const yaml = require('js-yaml')
 
 const {
   COMPONENT_DESC_FILENAME,
   CONTENT_CACHE_FOLDER,
-  CONTENT_GLOB,
+  CONTENT_SRC_GLOB,
+  CONTENT_SRC_OPTS,
   FILE_MODES,
   GIT_CORE,
   GIT_OPERATION_LABEL_LENGTH,
   GIT_PROGRESS_PHASES,
   PICOMATCH_VERSION_OPTS,
+  REF_PATTERN_CACHE_KEY,
   SYMLINK_FILE_MODE,
   VALID_STATE_FILENAME,
 } = require('./constants')
@@ -43,12 +51,16 @@ const VENTILATED_CSV_RX = /\s*,\s+/
 const EDIT_URL_TEMPLATE_VAR_RX = /\{(web_url|ref(?:hash|name)|path)\}/g
 const GIT_SUFFIX_RX = /(?:(?:(?:\.git)?\/)?\.git|\/)$/
 const GIT_URI_DETECTOR_RX = /:(?:\/\/|[^/\\])/
+const HEADS_DIR_RX = /^heads\//
 const HOSTED_GIT_REPO_RX = /^(?:https?:\/\/|.+@)(git(?:hub|lab)\.com|bitbucket\.org|pagure\.io)[/:](.+?)(?:\.git)?$/
+const HTTP_ERROR_CODE_RX = new RegExp('^' + git.Errors.HttpError.code + '$', 'i')
+const PATH_SEPARATOR_RX = /[/]/g
 const SHORTEN_REF_RX = /^refs\/(?:heads|remotes\/[^/]+|tags)\//
 const SPACE_RX = / /g
 const SUPERFLUOUS_SEPARATORS_RX = /^\/+|\/+$|\/+(?=\/)/g
 const URL_AUTH_CLEANER_RX = /^(https?:\/\/)[^/@]*@/
 const URL_AUTH_EXTRACTOR_RX = /^(https?:\/\/)(?:([^/:@]+)?(?::([^/@]+)?)?@)?(.*)/
+const URL_PORT_CLEANER_RX = /^([^/]+):[0-9]+(?=\/)/
 
 /**
  * Aggregates files from the specified content sources so they can be loaded
@@ -68,10 +80,8 @@ const URL_AUTH_EXTRACTOR_RX = /^(https?:\/\/)(?:([^/:@]+)?(?::([^/@]+)?)?@)?(.*)
  * @param {String} [playbook.runtime.cacheDir=undefined] - The base cache directory.
  * @param {Boolean} [playbook.runtime.fetch=undefined] - Whether to fetch
  * updates from managed git repositories.
- * @param {Boolean} [playbook.runtime.silent=false] - Whether to be silent
- * (suppresses progress bars and warnings).
- * @param {Boolean} [playbook.runtime.quiet=false] - Whether to be quiet
- * (suppresses progress bars).
+ * @param {Boolean} [playbook.runtime.quiet=false] - Whether to be suppress progress
+ * bars that show progress of clone and fetch operations.
  * @param {Array} playbook.git - The git configuration object for Antora.
  * @param {Boolean} [playbook.git.ensureGitSuffix=true] - Whether the .git
  * suffix is automatically appended to each repository URL, if missing.
@@ -82,116 +92,143 @@ const URL_AUTH_EXTRACTOR_RX = /^(https?:\/\/)(?:([^/:@]+)?(?::([^/@]+)?)?@)?(.*)
 function aggregateContent (playbook) {
   const startDir = playbook.dir || '.'
   const { branches, editUrl, tags, sources } = playbook.content
-  const sourcesByUrl = sources.reduce(
-    (accum, source) => accum.set(source.url, [...(accum.get(source.url) || []), source]),
-    new Map()
-  )
-  const { cacheDir, fetch, silent, quiet } = playbook.runtime
-  const progress = !quiet && !silent && createProgress(sourcesByUrl.keys(), process.stdout)
-  const { ensureGitSuffix, credentials } = Object.assign({ ensureGitSuffix: true }, playbook.git)
-  const credentialManager = registerGitPlugins(credentials, playbook.network || {}, startDir).get('credentialManager')
-  return ensureCacheDir(cacheDir, startDir)
-    .then((resolvedCacheDir) =>
+  const sourceDefaults = { branches, editUrl, tags }
+  const { cacheDir: requestedCacheDir, fetch, quiet } = playbook.runtime
+  return ensureCacheDir(requestedCacheDir, startDir).then((cacheDir) => {
+    const gitConfig = Object.assign({ ensureGitSuffix: true }, playbook.git)
+    const gitPlugins = loadGitPlugins(gitConfig, playbook.network || {}, startDir)
+    const fetchConcurrency = Math.max(gitConfig.fetchConcurrency || Infinity, 1)
+    const sourcesByUrl = sources.reduce((accum, source) => {
+      return accum.set(source.url, [...(accum.get(source.url) || []), Object.assign({}, sourceDefaults, source)])
+    }, new Map())
+    const progress = !quiet && createProgress(sourcesByUrl.keys(), process.stdout)
+    const refPatternCache = Object.assign(new Map(), { braces: new Map() })
+    const loadOpts = { cacheDir, fetch, gitPlugins, progress, startDir, refPatternCache }
+    return collectFiles(sourcesByUrl, loadOpts, fetchConcurrency).then(buildAggregate, (err) => {
+      progress && progress.terminate()
+      throw err
+    })
+  })
+}
+
+async function collectFiles (sourcesByUrl, loadOpts, concurrency) {
+  const tasks = [...sourcesByUrl.entries()].map(([url, sources]) => [
+    () => loadRepository(url, Object.assign({ fetchTags: tagsSpecified(sources) }, loadOpts)),
+    ({ repo, authStatus }) =>
       Promise.all(
-        [...sourcesByUrl.entries()].map(([url, sources]) =>
-          loadRepository(url, {
-            cacheDir: resolvedCacheDir,
-            credentialManager,
-            fetchTags: tagsSpecified(sources, tags),
-            progress,
-            fetch,
-            startDir,
-            ensureGitSuffix,
-          }).then(({ repo, authStatus }) =>
-            Promise.all(
-              sources.map((source) => {
-                source = Object.assign({ branches, editUrl, tags }, source)
-                // NOTE if repository is managed (has a url), we can assume the remote name is origin
-                // TODO if the repo has no remotes, then remoteName should be undefined
-                const remoteName = repo.url ? 'origin' : source.remote || 'origin'
-                return collectFilesFromSource(source, repo, remoteName, authStatus)
-              })
-            )
-          )
-        )
-      )
-        .then(buildAggregate)
-        .catch((err) => {
-          progress && progress.terminate()
-          throw err
+        sources.map((source) => {
+          // NOTE if repository is managed (has a url property), we can assume the remote name is origin
+          // TODO if the repo has no remotes, then remoteName should be undefined
+          const remoteName = repo.url ? 'origin' : source.remote || 'origin'
+          return collectFilesFromSource(source, repo, remoteName, authStatus)
         })
-    )
-    .finally(unregisterGitPlugins)
+      ),
+  ])
+  let rejected, started
+  const startedContinuations = []
+  const recordRejection = (err) => {
+    throw (rejected = true) && err
+  }
+  const runTask = (primary, continuation, idx) =>
+    primary().then((value) => {
+      if (!rejected) startedContinuations[idx] = continuation(value).catch(recordRejection)
+    }, recordRejection)
+  if (tasks.length > concurrency) {
+    started = []
+    const pending = []
+    for (const [primary, continuation] of tasks) {
+      const current = runTask(primary, continuation, started.length).finally(() =>
+        pending.splice(pending.indexOf(current), 1)
+      )
+      started.push(current)
+      if (pending.push(current) < concurrency) continue
+      if (await Promise.race(pending).then(invariably.true, invariably.false)) continue
+      break
+    }
+  } else {
+    started = tasks.map(([primary, continuation], idx) => runTask(primary, continuation, idx))
+  }
+  return Promise.allSettled(started).then((outcomes) =>
+    Promise.allSettled(startedContinuations).then((continuationOutcomes) => {
+      const rejection = outcomes.push(...continuationOutcomes) && outcomes.find(({ status }) => status === 'rejected')
+      if (rejection) throw rejection.reason
+      return continuationOutcomes.map(({ value }) => value)
+    })
+  )
 }
 
 function buildAggregate (componentVersionBuckets) {
-  const aggregateMap = flattenDeep(componentVersionBuckets).reduce((accum, batch) => {
-    const key = batch.version + '@' + batch.name
-    const entry = accum.get(key)
-    return accum.set(key, entry ? Object.assign(entry, batch, { files: [...entry.files, ...batch.files] }) : batch)
-  }, new Map())
-  return [...aggregateMap.values()]
+  return [
+    ...flattenDeep(componentVersionBuckets)
+      .reduce((accum, batch) => {
+        const key = batch.version + '@' + batch.name
+        const entry = accum.get(key)
+        if (!entry) return accum.set(key, batch)
+        const files = batch.files
+        ;(batch.files = entry.files).push(...files)
+        Object.assign(entry, batch)
+        return accum
+      }, new Map())
+      .values(),
+  ]
 }
 
 async function loadRepository (url, opts) {
-  let dir
-  let repo
-  let authStatus
+  let authStatus, dir, repo
+  const cache = { [REF_PATTERN_CACHE_KEY]: opts.refPatternCache }
   if (~url.indexOf(':') && GIT_URI_DETECTOR_RX.test(url)) {
-    let displayUrl
-    let credentials
+    let credentials, displayUrl
     ;({ displayUrl, url, credentials } = extractCredentials(url))
-    dir = ospath.join(opts.cacheDir, generateCloneFolderName(displayUrl))
+    const { cacheDir, fetch, fetchTags, gitPlugins, progress } = opts
+    dir = ospath.join(cacheDir, generateCloneFolderName(displayUrl))
     // NOTE the presence of the url property on the repo object implies the repository is remote
-    repo = { core: GIT_CORE, dir, gitdir: dir, url, noGitSuffix: !opts.ensureGitSuffix, noCheckout: true }
-    const credentialManager = opts.credentialManager
-    const validStateFile = ospath.join(repo.gitdir, VALID_STATE_FILENAME)
+    repo = { cache, dir, fs, gitdir: dir, noCheckout: true, url }
+    const validStateFile = ospath.join(dir, VALID_STATE_FILENAME)
     try {
       await fsp.access(validStateFile)
-      if (opts.fetch) {
+      if (fetch) {
         await fsp.unlink(validStateFile)
-        const fetchOpts = getFetchOptions(repo, opts.progress, displayUrl, credentials, opts.fetchTags, 'fetch')
+        const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetchTags, 'fetch')
         await git
           .fetch(fetchOpts)
           .then(() => {
+            const credentialManager = gitPlugins.credentialManager
             authStatus = credentials ? 'auth-embedded' : credentialManager.status({ url }) ? 'auth-required' : undefined
-            return git.config(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
+            return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
           })
           .catch((fetchErr) => {
-            fetchOpts.emitter && fetchOpts.emitter.emit('error', fetchErr)
-            if (fetchErr.code === git.E.HTTPError && fetchErr.data.statusCode === 401) fetchErr.rethrow = true
+            if (fetchOpts.onProgress) fetchOpts.onProgress.finish(fetchErr)
+            if (HTTP_ERROR_CODE_RX.test(fetchErr.code) && fetchErr.data.statusCode === 401) fetchErr.rethrow = true
             throw fetchErr
           })
           .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-          .then(() => fetchOpts.emitter && fetchOpts.emitter.emit('complete'))
+          .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
       } else {
-        // NOTE use cached value from previous fetch
-        authStatus = await git.config(Object.assign({ path: 'remote.origin.private' }, repo))
+        authStatus = await git.getConfig(Object.assign({ path: 'remote.origin.private' }, repo))
       }
     } catch (gitErr) {
-      await rmdir(dir)
+      await fsp['rm' in fsp ? 'rm' : 'rmdir'](dir, { recursive: true, force: true })
       if (gitErr.rethrow) throw transformGitCloneError(gitErr, displayUrl)
-      const fetchOpts = getFetchOptions(repo, opts.progress, displayUrl, credentials, opts.fetchTags, 'clone')
+      const fetchOpts = buildFetchOptions(repo, progress, displayUrl, credentials, gitPlugins, fetchTags, 'clone')
       await git
         .clone(fetchOpts)
         .then(() => git.resolveRef(Object.assign({ ref: 'HEAD', depth: 1 }, repo)))
         .then(() => {
+          const credentialManager = gitPlugins.credentialManager
           authStatus = credentials ? 'auth-embedded' : credentialManager.status({ url }) ? 'auth-required' : undefined
-          return git.config(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
+          return git.setConfig(Object.assign({ path: 'remote.origin.private', value: authStatus }, repo))
         })
-        .catch(async (cloneErr) => {
-          await rmdir(dir)
+        .catch((cloneErr) => {
           // FIXME triggering the error handler here causes assertion problems in the test suite
-          //fetchOpts.emitter && fetchOpts.emitter.emit('error', cloneErr)
+          //if (fetchOpts.onProgress) fetchOpts.onProgress.finish(cloneErr)
           throw transformGitCloneError(cloneErr, displayUrl)
         })
         .then(() => fsp.writeFile(validStateFile, '').catch(invariably.void))
-        .then(() => fetchOpts.emitter && fetchOpts.emitter.emit('complete'))
+        .then(() => fetchOpts.onProgress && fetchOpts.onProgress.finish())
     }
-  } else if (await isDirectory((dir = expandPath(url, '~+', opts.startDir)))) {
-    repo = (await isDirectory(ospath.join(dir, '.git')))
-      ? { core: GIT_CORE, dir }
-      : { core: GIT_CORE, dir, gitdir: dir, noCheckout: true }
+  } else if (await isDirectory((dir = expandPath(url, { dot: opts.startDir })))) {
+    const gitdir = ospath.join(dir, '.git')
+    repo = (await isDirectory(gitdir)) ? { cache, dir, fs, gitdir } : { cache, dir, fs, gitdir: dir, noCheckout: true }
     try {
       await git.resolveRef(Object.assign({ ref: 'HEAD', depth: 1 }, repo))
     } catch {
@@ -214,8 +251,8 @@ function extractCredentials (url) {
     // BitBucket: x-token-auth:<token>@
     const [, scheme, username, password, rest] = url.match(URL_AUTH_EXTRACTOR_RX)
     const displayUrl = (url = scheme + rest)
-    // NOTE if only username is present, assume it's an oauth token
-    const credentials = username ? (password == null ? { token: username } : { username, password }) : {}
+    // NOTE if only username is present, assume it's an oauth token and set password to empty string
+    const credentials = username ? { username, password: password || '' } : {}
     return { displayUrl, url, credentials }
   } else if (url.startsWith('git@')) {
     return { displayUrl: url, url: 'https://' + url.substr(4).replace(':', '/') }
@@ -235,16 +272,18 @@ async function collectFilesFromSource (source, repo, remoteName, authStatus) {
 async function selectReferences (source, repo, remote) {
   let { branches: branchPatterns, tags: tagPatterns, worktrees: worktreePatterns = '.' } = source
   const isBare = repo.noCheckout
+  const patternCache = repo.cache[REF_PATTERN_CACHE_KEY]
+  const noWorktree = repo.url ? undefined : null
   const refs = new Map()
   if (tagPatterns) {
     tagPatterns = Array.isArray(tagPatterns)
       ? tagPatterns.map((pattern) => String(pattern))
-      : String(tagPatterns).split(CSV_RX)
+      : splitRefPatterns(String(tagPatterns))
     if (tagPatterns.length) {
       const tags = await git.listTags(repo)
-      for (const shortname of tags.length ? matcher(tags, tagPatterns) : tags) {
+      for (const shortname of tags.length ? filterRefs(tags, tagPatterns, patternCache) : tags) {
         // NOTE tags are stored using symbol keys to distinguish them from branches
-        refs.set(Symbol(shortname), { shortname, fullname: 'tags/' + shortname, type: 'tag' })
+        refs.set(Symbol(shortname), { shortname, fullname: 'tags/' + shortname, type: 'tag', head: noWorktree })
       }
     }
   }
@@ -257,7 +296,7 @@ async function selectReferences (source, repo, remote) {
       } else {
         worktreePatterns = Array.isArray(worktreePatterns)
           ? worktreePatterns.map((pattern) => String(pattern))
-          : String(worktreePatterns).split(CSV_RX)
+          : splitRefPatterns(String(worktreePatterns))
       }
     }
     const branchPatternsString = String(branchPatterns)
@@ -268,16 +307,15 @@ async function selectReferences (source, repo, remote) {
       } else {
         if (!isBare) {
           // NOTE current branch is undefined when HEAD is detached
-          const ref = { shortname: 'HEAD', fullname: 'HEAD', type: 'branch', detached: true }
-          if (worktreePatterns[0] === '.') ref.head = repo.dir
-          refs.set('HEAD', ref)
+          const head = worktreePatterns[0] === '.' ? repo.dir : noWorktree
+          refs.set('HEAD', { shortname: 'HEAD', fullname: 'HEAD', type: 'branch', detached: true, head })
         }
         return [...refs.values()]
       }
     } else if (
       (branchPatterns = Array.isArray(branchPatterns)
         ? branchPatterns.map((pattern) => String(pattern))
-        : branchPatternsString.split(CSV_RX)).length
+        : splitRefPatterns(branchPatternsString)).length
     ) {
       let headBranchIdx
       // NOTE we can assume at least two entries if HEAD or . are present
@@ -292,10 +330,13 @@ async function selectReferences (source, repo, remote) {
           }
         } else {
           if (!isBare) {
+            let head = noWorktree
+            if (worktreePatterns[0] === '.') {
+              worktreePatterns = worktreePatterns.slice(1)
+              head = repo.dir
+            }
             // NOTE current branch is undefined when HEAD is detached
-            const ref = { shortname: 'HEAD', fullname: 'HEAD', type: 'branch', detached: true }
-            if (worktreePatterns[0] === '.' && (worktreePatterns = worktreePatterns.slice(1))) ref.head = repo.dir
-            refs.set('HEAD', ref)
+            refs.set('HEAD', { shortname: 'HEAD', fullname: 'HEAD', type: 'branch', detached: true, head })
           }
           branchPatterns.splice(headBranchIdx, 1)
         }
@@ -306,8 +347,9 @@ async function selectReferences (source, repo, remote) {
     // NOTE isomorphic-git includes HEAD in list of remote branches (see https://isomorphic-git.org/docs/listBranches)
     const remoteBranches = (await git.listBranches(Object.assign({ remote }, repo))).filter((it) => it !== 'HEAD')
     if (remoteBranches.length) {
-      for (const shortname of matcher(remoteBranches, branchPatterns)) {
-        refs.set(shortname, { shortname, fullname: path.join('remotes', remote, shortname), type: 'branch', remote })
+      for (const shortname of filterRefs(remoteBranches, branchPatterns, patternCache)) {
+        const fullname = 'remotes/' + remote + '/' + shortname
+        refs.set(shortname, { shortname, fullname, type: 'branch', remote, head: noWorktree })
       }
     }
     // NOTE only consider local branches if repo has a worktree or there are no remote tracking branches
@@ -315,17 +357,17 @@ async function selectReferences (source, repo, remote) {
       const localBranches = await git.listBranches(repo)
       if (localBranches.length) {
         const worktrees = await findWorktrees(repo, worktreePatterns)
-        for (const shortname of matcher(localBranches, branchPatterns)) {
-          const ref = { shortname, fullname: 'heads/' + shortname, type: 'branch' }
-          if (worktrees.has(shortname)) ref.head = worktrees.get(shortname)
-          refs.set(shortname, ref)
+        for (const shortname of filterRefs(localBranches, branchPatterns, patternCache)) {
+          const head = worktrees.get(shortname) || noWorktree
+          refs.set(shortname, { shortname, fullname: 'heads/' + shortname, type: 'branch', head })
         }
       }
     } else if (!remoteBranches.length) {
-      // QUESTION should local branches be used if the only remote branch is HEAD?
       const localBranches = await git.listBranches(repo)
-      for (const shortname of localBranches.length ? matcher(localBranches, branchPatterns) : localBranches) {
-        refs.set(shortname, { shortname, fullname: 'heads/' + shortname, type: 'branch' })
+      if (localBranches.length) {
+        for (const shortname of filterRefs(localBranches, branchPatterns, patternCache)) {
+          refs.set(shortname, { shortname, fullname: 'heads/' + shortname, type: 'branch', head: noWorktree })
+        }
       }
     }
   }
@@ -366,7 +408,7 @@ async function collectFilesFromReference (source, repo, remoteName, authStatus,
       ? resolvePathGlobsFs(worktreePath, startPaths)
       : resolvePathGlobsGit(repo, ref.oid, startPaths))
     if (!startPaths.length) {
-      const refInfo = `ref: ${ref.fullname.replace(/^heads\//, '')}${worktreePath ? ' <worktree>' : ''}`
+      const refInfo = `ref: ${ref.fullname.replace(HEADS_DIR_RX, '')}${worktreePath ? ' <worktree>' : ''}`
       throw new Error(`no start paths found in ${displayUrl} (${refInfo})`)
     }
     return Promise.all(
@@ -386,12 +428,12 @@ function collectFilesFromStartPath (startPath, repo, authStatus, ref, worktreePa
   )
     .then((files) => {
       const componentVersionBucket = loadComponentDescriptor(files, ref, version)
-      const origin = computeOrigin(originUrl, authStatus, ref, startPath, worktreePath, editUrl)
+      const origin = computeOrigin(originUrl, authStatus, repo.gitdir, ref, startPath, worktreePath, editUrl)
       componentVersionBucket.files = files.map((file) => assignFileProperties(file, origin))
       return componentVersionBucket
     })
     .catch((err) => {
-      const refInfo = `ref: ${ref.fullname.replace(/^heads\//, '')}${worktreePath ? ' <worktree>' : ''}`
+      const refInfo = `ref: ${ref.fullname.replace(HEADS_DIR_RX, '')}${worktreePath ? ' <worktree>' : ''}`
       const pathInfo = !startPath || err.message.startsWith('the start path ') ? '' : ' | path: ' + startPath
       throw Object.assign(err, { message: `${err.message} in ${repo.url || repo.dir} (${refInfo}${pathInfo})` })
     })
@@ -399,28 +441,32 @@ function collectFilesFromStartPath (startPath, repo, authStatus, ref, worktreePa
 
 function readFilesFromWorktree (worktreePath, startPath) {
   const cwd = ospath.join(worktreePath, startPath)
-  return fsp
-    .stat(cwd)
-    .catch(() => {
-      throw new Error(`the start path '${startPath}' does not exist`)
-    })
-    .then((stat) => {
+  return fsp.stat(cwd).then(
+    (stat) => {
       if (!stat.isDirectory()) throw new Error(`the start path '${startPath}' is not a directory`)
       return new Promise((resolve, reject) =>
         vfs
-          .src(CONTENT_GLOB, { cwd, follow: true, removeBOM: false })
+          .src(CONTENT_SRC_GLOB, Object.assign({ cwd }, CONTENT_SRC_OPTS))
           .on('error', (err) => {
-            if (err.code === 'ENOENT') {
-              err.message = `Broken symbolic link detected at ${ospath.relative(cwd, err.path)}`
+            if (err.code === 'ENOENT' && err.syscall === 'stat') {
+              try {
+                if (fs.lstatSync(err.path).isSymbolicLink()) {
+                  err.message = `Broken symbolic link detected at ${ospath.relative(cwd, err.path)}`
+                }
+              } catch {}
             } else if (err.code === 'ELOOP') {
               err.message = `Symbolic link cycle detected at ${ospath.relative(cwd, err.path)}`
             }
             reject(err)
           })
           .pipe(relativizeFiles())
-          .pipe(collectFiles(resolve))
+          .pipe(collectDataFromStream(resolve))
       )
-    })
+    },
+    () => {
+      throw new Error(`the start path '${startPath}' does not exist`)
+    }
+  )
 }
 
 /**
@@ -449,11 +495,11 @@ function relativizeFiles () {
   })
 }
 
-function collectFiles (done) {
+function collectDataFromStream (done) {
   const accum = []
   return map(
-    (file, enc, next) => {
-      accum.push(file)
+    (obj, _, next) => {
+      accum.push(obj)
       next()
     },
     () => done(accum)
@@ -471,14 +517,13 @@ function readFilesFromGitTree (repo, oid, startPath) {
 }
 
 function getGitTreeAtStartPath (repo, oid, startPath) {
-  return git
-    .readTree(Object.assign({ oid, filepath: startPath }, repo))
-    .catch(({ code }) => {
-      throw new Error(
-        `the start path '${startPath}' ${code === git.E.ResolveTreeError ? 'is not a directory' : 'does not exist'}`
-      )
-    })
-    .then((result) => Object.assign(result, { dirname: startPath }))
+  return git.readTree(Object.assign({ oid, filepath: startPath }, repo)).then(
+    (result) => Object.assign(result, { dirname: startPath }),
+    (err) => {
+      const m = err instanceof ObjectTypeError && err.data.expected === 'tree' ? 'is not a directory' : 'does not exist'
+      throw new Error(`the start path '${startPath}' ${m}`)
+    }
+  )
 }
 
 function srcGitTree (repo, root, start) {
@@ -497,9 +542,11 @@ function createGitTreeWalker (repo, root, filter) {
     walk (start) {
       return (
         visitGitTree(this, repo, root, filter, start)
-          .then(() => this.emit('end'))
           // NOTE if error is thrown, promises already being resolved won't halt
-          .catch((err) => this.emit('error', err))
+          .then(
+            () => this.emit('end'),
+            (err) => this.emit('error', err)
+          )
       )
     },
   })
@@ -522,23 +569,24 @@ function visitGitTree (emitter, repo, root, filter, parent, dirname = '', follow
         let mode
         if (entry.mode === SYMLINK_FILE_MODE) {
           reads.push(
-            readGitSymlink(repo, root, parent, entry, following)
-              .catch((err) => {
-                // NOTE this error could be caught after promie chain has already been rejected
-                if (err.code === git.E.TreeOrBlobNotFoundError) {
-                  err.message = `Broken symbolic link detected at ${vfilePath}`
-                } else if (err.code === 'SymbolicLinkCycleError') {
-                  err.message = `Symbolic link cycle detected at ${vfilePath}`
-                }
-                throw err
-              })
-              .then((target) => {
+            readGitSymlink(repo, root, parent, entry, following).then(
+              (target) => {
                 if (target.type === 'tree') {
                   return visitGitTree(emitter, repo, root, filter, target, vfilePath, new Set(following).add(entry.oid))
                 } else if (target.type === 'blob' && filterVerdict === true && (mode = FILE_MODES[target.mode])) {
                   emitter.emit('entry', Object.assign({ mode, oid: target.oid, path: vfilePath }, repo))
                 }
-              })
+              },
+              (err) => {
+                // NOTE this error could be caught after promise chain has already been rejected
+                if (err instanceof NotFoundError) {
+                  err.message = `Broken symbolic link detected at ${vfilePath}`
+                } else if (err.code === 'SymbolicLinkCycleError') {
+                  err.message = `Symbolic link cycle detected at ${vfilePath}`
+                }
+                throw err
+              }
+            )
           )
         } else if ((mode = FILE_MODES[entry.mode])) {
           emitter.emit('entry', Object.assign({ mode, oid: entry.oid, path: vfilePath }, repo))
@@ -552,11 +600,11 @@ function visitGitTree (emitter, repo, root, filter, parent, dirname = '', follow
 function readGitSymlink (repo, root, parent, { oid }, following) {
   if (following.size !== (following = new Set(following).add(oid)).size) {
     return git.readBlob(Object.assign({ oid }, repo)).then(({ blob: target }) => {
-      target = posixify && process.env.NODE_ENV === 'test' ? posixify(target.toString()) : target.toString()
+      target = decodeUint8Array(target)
       let targetParent
       if (parent.dirname) {
         const dirname = parent.dirname + '/'
-        target = path.join(dirname, target)
+        target = path.join(dirname, target) // join doesn't remove trailing separator
         if (target.startsWith(dirname)) {
           target = target.substr(dirname.length)
           targetParent = parent
@@ -564,10 +612,12 @@ function readGitSymlink (repo, root, parent, { oid }, following) {
           targetParent = root
         }
       } else {
-        target = path.normalize(target)
+        target = path.normalize(target) // normalize doesn't remove trailing separator
         targetParent = root
       }
-      return readGitObjectAtPath(repo, root, targetParent, target.split('/'), following)
+      const targetSegments = target.split('/')
+      if (!targetSegments[targetSegments.length - 1]) targetSegments.pop()
+      return readGitObjectAtPath(repo, root, targetParent, targetSegments, following)
     })
   }
   const err = { name: 'SymbolicLinkCycleError', code: 'SymbolicLinkCycleError', oid }
@@ -591,33 +641,25 @@ function readGitObjectAtPath (repo, root, parent, pathSegments, following) {
           : Promise.resolve(entry)
     }
   }
-  const err = {
-    name: git.E.TreeOrBlobNotFoundError,
-    code: git.E.TreeOrBlobNotFoundError,
-    oid: parent.oid,
-    filepath: pathSegments.join('/'),
-  }
-  return Promise.reject(Object.assign(new Error(`No file or directory found at "${err.oid}:${err.filepath}".`), err))
+  return Promise.reject(new NotFoundError(`No file or directory found at "${parent.oid}:${pathSegments.join('/')}"`))
 }
 
 /**
- * Returns true if the entry should be processed or false if it should be skipped.
- * Ignores files that begin with dot ('.') (entry.path is a basename) or that do
- * not have a file extension.
+ * Returns true (or 'treeOnly' if the entry is a symlink tree) if the entry
+ * should be processed or false if it should be skipped. An entry with a path
+ * (basename) that begins with dot ('.') is marked as skipped.
  */
 function filterGitEntry (entry) {
-  return (
-    entry.path.charAt() !== '.' &&
-    (entry.type !== 'blob' || entry.path.indexOf('.') > 0 || (entry.mode === SYMLINK_FILE_MODE ? 'treeOnly' : false))
-  )
+  const entryPath = entry.path
+  if (entryPath.charAt() === '.') return false
+  if (entry.type === 'tree') return entry.mode === SYMLINK_FILE_MODE ? 'treeOnly' : true
+  return entryPath.charAt(entryPath.length - 1) !== '~'
 }
 
 function entryToFile (entry) {
   return git.readBlob(entry).then(({ blob: contents }) => {
-    const stat = new fs.Stats()
-    stat.mode = entry.mode
-    stat.mtime = undefined
-    stat.size = contents.length
+    contents = Buffer.from(contents.buffer)
+    const stat = Object.assign(new fs.Stats(), { mode: entry.mode, mtime: undefined, size: contents.byteLength })
     return new File({ path: entry.path, contents, stat })
   })
 }
@@ -643,7 +685,7 @@ function loadComponentDescriptor (files, ref, version) {
     if (version === undefined) throw new Error(`${COMPONENT_DESC_FILENAME} is missing a version`)
     version = ''
   } else if (version === true) {
-    version = ref.shortname.replace(/[/]/g, '-')
+    version = ref.shortname.replace(PATH_SEPARATOR_RX, '-')
   } else if (version.constructor === Object) {
     const refname = ref.shortname
     let matched
@@ -662,7 +704,7 @@ function loadComponentDescriptor (files, ref, version) {
     if (matched === '.' || matched === '..') {
       throw new Error(`version in ${COMPONENT_DESC_FILENAME} cannot have path segments: ${matched}`)
     }
-    version = matched.replace(/[/]/g, '-')
+    version = matched.replace(PATH_SEPARATOR_RX, '-')
   } else if ((version = String(version)) === '.' || version === '..' || ~version.indexOf('/')) {
     throw new Error(`version in ${COMPONENT_DESC_FILENAME} cannot have path segments: ${version}`)
   }
@@ -670,22 +712,23 @@ function loadComponentDescriptor (files, ref, version) {
   return camelCaseKeys(data, { deep: true, stopPaths: ['asciidoc'] })
 }
 
-function computeOrigin (url, authStatus, ref, startPath, worktreePath = undefined, editUrl = true) {
+function computeOrigin (url, authStatus, gitdir, ref, startPath, worktreePath = undefined, editUrl = true) {
   const { shortname: refname, oid: refhash, type: reftype } = ref
-  const remote = !url.startsWith('file://')
-  const origin = { type: 'git', refname, startPath }
+  const origin = { type: 'git', url, gitdir, refname, [reftype]: refname, startPath }
   if (authStatus) origin.private = authStatus
-  origin[reftype] = refname
-  if (worktreePath) {
-    if (remote) origin.url = url
-    origin.fileUriPattern =
-      (posixify ? 'file:///' + posixify(worktreePath) : 'file://' + worktreePath) + path.join('/', startPath, '%s')
-    origin.worktree = worktreePath
-  } else {
-    origin.url = url
+  if (worktreePath === undefined) {
     origin.refhash = refhash
+  } else {
+    if (worktreePath) {
+      origin.fileUriPattern =
+        (posixify ? 'file:///' + posixify(worktreePath) : 'file://' + worktreePath) + path.join('/', startPath, '%s')
+    } else {
+      origin.refhash = refhash
+    }
+    origin.worktree = worktreePath
+    if (url.startsWith('file://')) url = undefined
   }
-  if (remote) origin.webUrl = url.replace(GIT_SUFFIX_RX, '')
+  if (url) origin.webUrl = url.replace(GIT_SUFFIX_RX, '')
   if (editUrl === true) {
     let match
     if (url && (match = url.match(HOSTED_GIT_REPO_RX))) {
@@ -728,9 +771,14 @@ function assignFileProperties (file, origin) {
   return file
 }
 
-function getFetchOptions (repo, progress, url, credentials, fetchTags, operation) {
-  const opts = Object.assign({ depth: 1 }, credentials, repo)
-  if (progress) opts.emitter = createProgressEmitter(progress, url, operation)
+function buildFetchOptions (repo, progress, displayUrl, credentialsFromUrl, gitPlugins, fetchTags, operation) {
+  const { credentialManager, http, urlRouter } = gitPlugins
+  const onAuth = resolveCredentials.bind(credentialManager, new Map().set(undefined, credentialsFromUrl))
+  const onAuthFailure = onAuth
+  const onAuthSuccess = (url) => credentialManager.approved({ url })
+  const opts = Object.assign({ corsProxy: false, depth: 1, http, onAuth, onAuthFailure, onAuthSuccess }, repo)
+  if (urlRouter) opts.url = urlRouter.ensureGitSuffix(opts.url)
+  if (progress) opts.onProgress = createProgressListener(progress, displayUrl, operation)
   if (operation === 'fetch') {
     opts.prune = true
     if (fetchTags) opts.tags = opts.pruneTags = true
@@ -756,7 +804,7 @@ function createProgress (urls, term) {
   }
 }
 
-function createProgressEmitter (progress, progressLabel, operation) {
+function createProgressListener (progress, progressLabel, operation) {
   const progressBar = progress.newBar(formatProgressBar(progressLabel, progress.maxLabelWidth, operation), {
     complete: '#',
     incomplete: '-',
@@ -767,10 +815,7 @@ function createProgressEmitter (progress, progressLabel, operation) {
   // NOTE leave room for indeterminate progress at end of bar; this isn't strictly needed for a bare clone
   progressBar.scaleFactor = Math.max(0, (ticks - 1) / ticks)
   progressBar.tick(0)
-  return new EventEmitter()
-    .on('progress', onGitProgress.bind(null, progressBar))
-    .on('complete', onGitComplete.bind(null, progressBar))
-    .on('error', onGitComplete.bind(null, progressBar))
+  return Object.assign(onGitProgress.bind(progressBar), { finish: onGitComplete.bind(progressBar) })
 }
 
 function formatProgressBar (label, maxLabelWidth, operation) {
@@ -785,29 +830,46 @@ function formatProgressBar (label, maxLabelWidth, operation) {
   return `[${operation}] ${label}${padding} [:bar]`
 }
 
-function onGitProgress (progressBar, { phase, loaded, total }) {
+function onGitProgress ({ phase, loaded, total }) {
   const phaseIdx = GIT_PROGRESS_PHASES.indexOf(phase)
   if (~phaseIdx) {
-    const scaleFactor = progressBar.scaleFactor
+    const scaleFactor = this.scaleFactor
     let ratio = ((loaded / total) * scaleFactor) / GIT_PROGRESS_PHASES.length
     if (phaseIdx) ratio += (phaseIdx * scaleFactor) / GIT_PROGRESS_PHASES.length
     // NOTE: updates are automatically throttled based on renderThrottle option
-    progressBar.update(ratio > scaleFactor ? scaleFactor : ratio)
+    this.update(ratio > scaleFactor ? scaleFactor : ratio)
   }
 }
 
-function onGitComplete (progressBar, err) {
+function onGitComplete (err) {
   if (err) {
     // TODO: could use progressBar.interrupt() to replace bar with message instead
-    progressBar.chars.incomplete = '?'
-    progressBar.update(0)
+    this.chars.incomplete = '?'
+    this.update(0)
     // NOTE: force progress bar to update regardless of throttle setting
-    progressBar.render(undefined, true)
+    this.render(undefined, true)
   } else {
-    progressBar.update(1)
+    this.update(1)
   }
 }
 
+function resolveCredentials (credentialsFromUrlHolder, url, auth) {
+  const credentialsFromUrl = credentialsFromUrlHolder.get()
+  if ('Authorization' in auth.headers) {
+    if (!credentialsFromUrl) return this.rejected({ url, auth })
+    credentialsFromUrlHolder.clear()
+  } else if (credentialsFromUrl) {
+    return credentialsFromUrl
+  } else {
+    auth = undefined
+  }
+  return this.fill({ url }).then((credentials) =>
+    credentials
+      ? { username: credentials.token || credentials.username, password: credentials.token ? '' : credentials.password }
+      : this.rejected({ url, auth })
+  )
+}
+
 /**
  * Generates a safe, unique folder name for a git URL.
  *
@@ -834,16 +896,20 @@ function generateCloneFolderName (url) {
  *
  * @param {Repository} repo - The repository on which to operate.
  * @param {String} remoteName - The name of the remote to resolve.
- * @returns {String} The URL of the specified remote, if present.
+ * @returns {String} The URL of the specified remote, if defined, or the file URI to the local repository.
  */
 function resolveRemoteUrl (repo, remoteName) {
-  return git.config(Object.assign({ path: 'remote.' + remoteName + '.url' }, repo)).then((url) => {
-    if (!url) return posixify ? 'file:///' + posixify(repo.dir) : 'file://' + repo.dir
-    if (url.startsWith('https://') || url.startsWith('http://')) {
-      return ~url.indexOf('@') ? url.replace(URL_AUTH_CLEANER_RX, '$1') : url
-    } else if (url.startsWith('git@')) {
-      return 'https://' + url.substr(4).replace(':', '/')
+  return git.getConfig(Object.assign({ path: 'remote.' + remoteName + '.url' }, repo)).then((url) => {
+    if (url) {
+      if (url.startsWith('https://') || url.startsWith('http://')) {
+        return ~url.indexOf('@') ? url.replace(URL_AUTH_CLEANER_RX, '$1') : url
+      } else if (url.startsWith('git@')) {
+        return 'https://' + url.substr(4).replace(':', '/')
+      } else if (url.startsWith('ssh://')) {
+        return 'https://' + url.substr(url.indexOf('@') + 1 || 6).replace(URL_PORT_CLEANER_RX, '$1')
+      }
     }
+    return posixify ? 'file:///' + posixify(repo.dir) : 'file://' + repo.dir
   })
 }
 
@@ -854,74 +920,30 @@ function resolveRemoteUrl (repo, remoteName) {
  * @return {Boolean} A flag indicating whether the URL matches a directory on the local filesystem.
  */
 function isDirectory (url) {
-  return fsp
-    .stat(url)
-    .then((stat) => stat.isDirectory())
-    .catch(invariably.false)
-}
-
-/**
- * Removes the specified directory (including all of its contents) or file.
- * Equivalent to fs.promises.rmdir(dir, { recursive: true }) in Node 12.
- */
-function rmdir (dir) {
-  return fsp
-    .readdir(dir, { withFileTypes: true })
-    .then((lst) =>
-      Promise.all(
-        lst.map((it) =>
-          it.isDirectory()
-            ? rmdir(ospath.join(dir, it.name))
-            : fsp.unlink(ospath.join(dir, it.name)).catch((unlinkErr) => {
-              if (unlinkErr.code !== 'ENOENT') throw unlinkErr
-            })
-        )
-      )
-    )
-    .then(() => fsp.rmdir(dir))
-    .catch((err) => {
-      if (err.code === 'ENOENT') return
-      if (err.code === 'ENOTDIR') {
-        return fsp.unlink(dir).catch((unlinkErr) => {
-          if (unlinkErr.code !== 'ENOENT') throw unlinkErr
-        })
-      }
-      throw err
-    })
+  return fsp.stat(url).then((stat) => stat.isDirectory(), invariably.false)
 }
 
-function tagsSpecified (sources, defaultTags) {
-  return ~sources.findIndex((source) => {
-    const tags = source.tags || defaultTags || []
-    return Array.isArray(tags) ? tags.length : true
-  })
+function tagsSpecified (sources) {
+  return sources.some(({ tags }) => tags && (Array.isArray(tags) ? tags.length : true))
 }
 
-function registerGitPlugins (credentials, network, startDir) {
-  const plugins = git.cores.create(GIT_CORE)
-  if (!plugins.has('fs')) plugins.set('fs', Object.assign({ _managed: true }, fs))
-  let credentialManager
-  if (plugins.has('credentialManager')) {
-    credentialManager = plugins.get('credentialManager')
+function loadGitPlugins (gitConfig, networkConfig, startDir) {
+  const plugins = new Map((git.cores || git.default.cores || new Map()).get(GIT_CORE))
+  for (const [name, request] of Object.entries(gitConfig.plugins || {})) {
+    if (request) plugins.set(name, userRequire(request, { dot: startDir, paths: [startDir, __dirname] }))
+  }
+  let credentialManager, urlRouter
+  if ((credentialManager = plugins.get('credentialManager'))) {
     if (typeof credentialManager.configure === 'function') {
-      credentialManager.configure({ config: credentials, startDir })
-    }
-    if (typeof credentialManager.status !== 'function') {
-      plugins.set('credentialManager', Object.assign({}, credentialManager, { status () {} }))
+      credentialManager.configure({ config: gitConfig.credentials, startDir })
     }
+    if (typeof credentialManager.status !== 'function') Object.assign(credentialManager, { status () {} })
   } else {
-    credentialManager = new GitCredentialManagerStore().configure({ config: credentials, startDir })
-    credentialManager._managed = true
-    plugins.set('credentialManager', credentialManager)
-  }
-  if (!plugins.has('http') && (network.httpsProxy || network.httpProxy)) {
-    plugins.set('http', Object.assign(require('./git-plugin-http')(network), { _managed: true }))
+    credentialManager = new GitCredentialManagerStore().configure({ config: gitConfig.credentials, startDir })
   }
-  return plugins
-}
-
-function unregisterGitPlugins () {
-  git.cores.create(GIT_CORE).forEach((val, key, map) => val._managed && map.delete(key))
+  if (gitConfig.ensureGitSuffix) urlRouter = { ensureGitSuffix: (url) => (url.endsWith('.git') ? url : url + '.git') }
+  const http = plugins.get('http') || createHttpPlugin(networkConfig, 'git/isomorphic-git@' + git.version())
+  return { credentialManager, http, urlRouter }
 }
 
 /**
@@ -938,47 +960,52 @@ function ensureCacheDir (preferredCacheDir, startDir) {
   const baseCacheDir =
     preferredCacheDir == null
       ? getCacheDir('antora' + (process.env.NODE_ENV === 'test' ? '-test' : '')) || ospath.resolve('.antora/cache')
-      : expandPath(preferredCacheDir, '~+', startDir)
+      : expandPath(preferredCacheDir, { dot: startDir })
   const cacheDir = ospath.join(baseCacheDir, CONTENT_CACHE_FOLDER)
-  return fsp
-    .mkdir(cacheDir, { recursive: true })
-    .then(() => cacheDir)
-    .catch((err) => {
+  return fsp.mkdir(cacheDir, { recursive: true }).then(
+    () => cacheDir,
+    (err) => {
       throw Object.assign(err, { message: `Failed to create content cache directory: ${cacheDir}; ${err.message}` })
-    })
+    }
+  )
 }
 
 function transformGitCloneError (err, displayUrl) {
-  const { code, data, message, name, stack } = err
-  let wrappedMsg
-  let trimMessage
-  if (code === git.E.HTTPError) {
-    if (data.statusCode === 401) {
-      wrappedMsg = err.rejected
-        ? 'Content repository not found or credentials were rejected'
-        : 'Content repository not found or requires credentials'
-    } else if (data.statusCode === 404) {
-      wrappedMsg = 'Content repository not found'
-    } else {
-      wrappedMsg = message
-      trimMessage = true
+  let wrappedMsg, trimMessage
+  if (HTTP_ERROR_CODE_RX.test(err.code)) {
+    switch (err.data.statusCode) {
+      case 401:
+        wrappedMsg = err.rejected
+          ? 'Content repository not found or credentials were rejected'
+          : 'Content repository not found or requires credentials'
+        break
+      case 404:
+        wrappedMsg = 'Content repository not found'
+        break
+      default:
+        wrappedMsg = err.message
+        trimMessage = true
     }
-  } else if (code === git.E.RemoteUrlParseError || code === git.E.UnknownTransportError) {
+  } else if (err instanceof UrlParseError || err instanceof UnknownTransportError) {
     wrappedMsg = 'Content source uses an unsupported transport protocol'
-  } else if (code === 'ENOTFOUND') {
-    wrappedMsg = 'Content repository host could not be resolved: ' + err.hostname
+  } else if (err.code === 'ENOTFOUND') {
+    wrappedMsg = `Content repository host could not be resolved: ${err.hostname}`
   } else {
-    wrappedMsg = name + ': ' + message
+    wrappedMsg = `${err.name}: ${err.message}`
     trimMessage = true
   }
   if (trimMessage) {
     wrappedMsg = ~(wrappedMsg = wrappedMsg.trimRight()).indexOf('. ') ? wrappedMsg : wrappedMsg.replace(/\.$/, '')
   }
-  const wrappedErr = new Error(wrappedMsg + ' (url: ' + displayUrl + ')')
-  wrappedErr.stack += '\nCaused by: ' + (stack || 'unknown')
+  const wrappedErr = new Error(`${wrappedMsg} (url: ${displayUrl})`)
+  wrappedErr.stack += `\nCaused by: ${err.stack || 'unknown'}`
   return wrappedErr
 }
 
+function splitRefPatterns (str) {
+  return ~str.indexOf('{') ? str.split(VENTILATED_CSV_RX) : str.split(CSV_RX)
+}
+
 function coerceToString (value) {
   return value == null ? '' : String(value)
 }
@@ -991,11 +1018,11 @@ function findWorktrees (repo, patterns) {
   if (!patterns.length) return new Map()
   const linkedOnly = patterns[0] === '.' ? !(patterns = patterns.slice(1)) : true
   let worktreesDir
+  const patternCache = repo.cache[REF_PATTERN_CACHE_KEY]
   return (patterns.length
     ? fsp
       .readdir((worktreesDir = ospath.join(repo.dir, '.git', 'worktrees')))
-      .catch(invariably.emptyArray)
-      .then((worktreeNames) => matcher(worktreeNames, [...patterns]))
+      .then((worktreeNames) => filterRefs(worktreeNames, [...patterns], patternCache), invariably.emptyArray)
       .then((worktreeNames) =>
         worktreeNames.length
           ? Promise.all(