bare-module-traverse 2.3.1 → 2.4.1

package/README.md

@@ -1,6 +1,6 @@
 # bare-module-traverse
 
-Low-level module graph traversal for Bare. The algorithm is implemented as a generator function that yields either modules to be read, prefixes to be listed, child dependencies to be traversed, or resolved dependencies of the module graph. As a convenience, the main export is a synchronous and asynchronous iterable that relies on modules being read and prefixes being listed by callbacks. For asynchronous iteration, the callbacks may return promises which will be awaited before being passed to the generator.
+Low-level module graph traversal for Bare. The algorithm is implemented as a generator function that yields either modules to be read, modules to be probed for existence, resolutions to be transformed, prefixes to be listed, sets of imports to be resolved, child dependencies to be traversed, or resolved dependencies of the module graph. As a convenience, the main export is a synchronous and asynchronous iterable that relies on modules being read, modules being probed, resolutions being transformed, and prefixes being listed by callbacks. For asynchronous iteration, the callbacks may return promises which will be awaited before being passed to the generator.
 
 ```
 npm i bare-module-traverse
@@ -50,9 +50,9 @@ for await (const dependency of traverse(
 
 ## API
 
-#### `const dependencies = traverse(url[, options], readModule[, listPrefix])`
+#### `const dependencies = traverse(url[, options], readModule[, listPrefix[, probeModule[, resolveModule]]])`
 
-Traverse the module graph rooted at `url`, which must be a WHATWG `URL` instance. `readModule` is called with a `URL` instance for every module to be read and must either return the module source, if it exists, or `null`. `listPrefix` is called with a `URL` instance of every prefix to be listed and must yield `URL` instances that have the specified `URL` as a prefix. If not provided, prefixes won't be traversed. If `readModule` returns a promise or `listPrefix` returns a promise generator, synchronous iteration is not supported.
+Traverse the module graph rooted at `url`, which must be a WHATWG `URL` instance. `readModule` is called with a `URL` instance for every module to be read and must either return the module source, if it exists, or `null`. `listPrefix` is called with a `URL` instance of every prefix to be listed and must yield `URL` instances that have the specified `URL` as a prefix. If not provided, prefixes won't be traversed. `probeModule` is called with a `URL` instance to test whether a module exists and must return `true` if it does, `false` if it doesn't, or `undefined` if probing isn't supported; this lets existence be checked without reading the full module source, such as when locating an addon or asset. When it returns `undefined`, existence is instead determined by reading the module, so no source is read twice. If not provided, `probeModule` returns `undefined` and no probing is performed. `resolveModule` is called with a `URL` instance for every resolved, existing module and must return the `URL` to use in its place, applying any post-resolution transform; a file system implementation would canonicalize symlinks here with `realpath` so a module reached through different symlinks dedupes against its real location. If not provided, resolutions are used unchanged. If `readModule`, `probeModule`, or `resolveModule` returns a promise, or `listPrefix` returns a promise generator, synchronous iteration is not supported.
 
 Options include:
 
@@ -165,22 +165,59 @@ The following generator functions implement the traversal algorithm. The yielded
 
 **Source module**
 
+A module to be read. The driver returns its source if it exists, otherwise `null`. When `artifact` is `true`, the module is an addon or asset whose contents are loaded lazily and referenced by path. A driver that only needs to locate such artifacts, such as a module loader, may return `null` without reading, having already established existence by probing; a driver that embeds their contents, such as a bundler, reads them as normal.
+
+```js
+next.value = {
+  module: URL,
+  artifact: boolean
+}
+```
+
+**Probed module**
+
+A module whose existence is to be tested without reading its full source, such as when locating an addon or asset. The driver returns `true` if it exists, `false` if it doesn't, or `undefined` if probing isn't supported, in which case existence is instead determined by reading the module.
+
 ```js
 next.value = {
-  module: URL
+  probe: URL
+}
+```
+
+**Resolved module**
+
+A resolved, existing module whose URL is to be transformed. The driver returns the URL to use in its place, applying any post-resolution transform, such as canonicalizing symlinks with `realpath`, or the URL unchanged.
+
+```js
+next.value = {
+  resolution: URL
 }
 ```
 
 **File prefix**
 
+A prefix to be listed. The driver returns the URLs that have it as a prefix, of which there may be none.
+
 ```js
 next.value = {
   prefix: URL
 }
 ```
 
+**Import set**
+
+A set of independent imports to resolve. Each generator must be driven to completion before the parent generator is resumed, since the parent's resolved imports aren't complete until they are. The generators yield the same values as any other and may themselves yield dependency subgraphs to be traversed. A driver may drive them one at a time or, as their resolutions are independent, concurrently.
+
+```js
+next.value = {
+  links: [Generator]
+}
+```
+
 **Dependency subgraph**
 
+A child subgraph to be traversed by driving its generator as the parent is driven. If `deferred` is `true`, it must be traversed only once all non-deferred subgraphs have been, ensuring, for example, that a module reached both as an import and as an asset is claimed by the import traversal first.
+
 ```js
 next.value = {
   children: Generator,
@@ -190,6 +227,8 @@ next.value = {
 
 **Dependency node**
 
+A fully resolved node of the module graph and the traversal's output. This is what the iterable forms yield to the caller.
+
 ```js
 next.value = {
   dependency: {
@@ -211,40 +250,68 @@ next.value = {
 }
 ```
 
-To drive the generator functions, a loop like the following can be used:
+To drive the generator functions, a recursive routine like the following can be used:
 
 ```js
-const queue = [traverse.module(url, source, artifacts, visited)]
+const artifacts = { addons: [], assets: [] }
+const visited = new Set()
 
-while (queue.length > 0) {
-  const generator = queue.pop()
+const queue = [traverse.module(url, null, {}, artifacts, visited)]
+const deferred = []
 
+function drive(generator) {
   let next = generator.next()
 
   while (next.done !== true) {
     const value = next.value
 
     if (value.module) {
-      // Read `value.module` if it exists, otherwise `null`
+      // Read `value.module` if it exists, otherwise `null`. When
+      // `value.artifact` is `true`, the module is an addon or asset that may be
+      // left unread, returning `null`, unless its contents are needed
       let source
 
       next = generator.next(source)
+    } else if (value.probe) {
+      // Test whether `value.probe` exists, returning `true`, `false`, or
+      // `undefined` if probing isn't supported
+      let exists
+
+      next = generator.next(exists)
+    } else if (value.resolution) {
+      // Transform `value.resolution`, e.g. canonicalize it with `realpath`, or
+      // pass it through unchanged
+      let resolution = value.resolution
+
+      next = generator.next(resolution)
     } else if (value.prefix) {
       // List the modules that have `value.prefix` as a prefix
       let modules
 
       next = generator.next(modules)
+    } else if (value.links) {
+      // Drive each import to completion before resuming; their resolutions are
+      // independent, so a concurrent driver may instead drive them in parallel
+      for (const link of value.links) drive(link)
+
+      next = generator.next()
+    } else if (value.children) {
+      // Defer the subgraph if requested, otherwise traverse it next
+      if (value.deferred) deferred.push(value.children)
+      else queue.push(value.children)
+
+      next = generator.next()
     } else {
-      if (value.children) {
-        queue.push(value.children)
-      } else {
-        const dependency = value.dependency
-      }
+      const dependency = value.dependency
 
       next = generator.next()
     }
   }
 }
+
+while (queue.length > 0 || deferred.length > 0) {
+  drive(queue.length > 0 ? queue.pop() : deferred.shift())
+}
 ```
 
 Options are the same as `traverse()` for all functions.
@@ -258,7 +325,9 @@ Options are the same as `traverse()` for all functions.
 
 #### `const generator = traverse.preresolved(url, source, resolutions, artifacts, visited[, options])`
 
-#### `const generator = traverse.imports(parentURL, source, imports, artifacts, visited[, options])`
+#### `const generator = traverse.imports(parentURL, source, imports, artifacts, lexer, visited[, options])`
+
+#### `const generator = traverse.link(entry, specifier, condition, parentURL, imports, artifacts, visited[, options])`
 
 #### `const generator = traverse.addons(parentURL, artifacts, visited[, options])`
 

package/index.d.ts

@@ -42,36 +42,50 @@ interface TraverseOptions extends ResolveOptions {
 declare function traverse(
   entry: URL,
   readModule: (url: URL) => Buffer | string | null,
-  listPrefix?: (url: URL) => Iterable<URL>
+  listPrefix?: (url: URL) => Iterable<URL>,
+  probeModule?: (url: URL) => boolean | undefined,
+  resolveModule?: (url: URL) => URL
 ): Iterable<Dependency>
 
 declare function traverse(
   entry: URL,
   readModule: (url: URL) => Promise<Buffer | string | null>,
-  listPrefix?: (url: URL) => AsyncIterable<URL>
+  listPrefix?: (url: URL) => AsyncIterable<URL>,
+  probeModule?: (url: URL) => Promise<boolean | undefined>,
+  resolveModule?: (url: URL) => Promise<URL>
 ): AsyncIterable<Dependency>
 
 declare function traverse(
   entry: URL,
   opts: TraverseOptions,
   readModule: (url: URL) => Buffer | string | null,
-  listPrefix?: (url: URL) => Iterable<URL>
+  listPrefix?: (url: URL) => Iterable<URL>,
+  probeModule?: (url: URL) => boolean | undefined,
+  resolveModule?: (url: URL) => URL
 ): Iterable<Dependency>
 
 declare function traverse(
   entry: URL,
   opts: TraverseOptions,
   readModule: (url: URL) => Promise<Buffer | string | null>,
-  listPrefix?: (url: URL) => AsyncIterable<URL>
+  listPrefix?: (url: URL) => AsyncIterable<URL>,
+  probeModule?: (url: URL) => Promise<boolean | undefined>,
+  resolveModule?: (url: URL) => Promise<URL>
 ): AsyncIterable<Dependency>
 
 declare namespace traverse {
   export { type TraverseOptions }
 
   export type Traversal = Generator<
-    { module: URL } | { prefix: URL } | { children: URL; deferred: boolean } | { dependency: URL },
+    | { module: URL; artifact: boolean }
+    | { probe: URL }
+    | { resolution: URL }
+    | { prefix: URL }
+    | { links: Traversal[] }
+    | { children: Traversal; deferred: boolean }
+    | { dependency: Dependency },
     boolean,
-    void | URL[] | Buffer | string | null
+    void | URL | URL[] | Buffer | string | boolean | null
   >
 
   export interface Artifacts {
@@ -120,12 +134,27 @@ declare namespace traverse {
     source: string | Buffer,
     imports: ImportsMap,
     artifacts: Artifacts,
+    lexer: {
+      imports: Import[]
+      exports: Export[]
+    },
     visited: Set<string>,
     opts?: TraverseOptions
   ): Traversal
 
-  export function prebuilds(
-    packageURL: URL,
+  export function link(
+    entry: Import,
+    specifier: string,
+    condition: string,
+    parentURL: URL,
+    imports: ImportsMap,
+    artifacts: Artifacts,
+    visited: Set<string>,
+    opts?: TraverseOptions
+  ): Traversal
+
+  export function addons(
+    parentURL: URL,
     artifacts: Artifacts,
     visited: Set<string>,
     opts?: TraverseOptions
@@ -133,7 +162,7 @@ declare namespace traverse {
 
   export function assets(
     patterns: ConditionalSpecifier,
-    packageURL: URL,
+    parentURL: URL,
     artifacts: Artifacts,
     visited: Set<string>,
     opts?: TraverseOptions

package/index.js

@@ -13,13 +13,33 @@ const constants = {
   TEXT: 7
 }
 
-module.exports = exports = function traverse(entry, opts, readModule, listPrefix) {
+function defaultResolveModule(url) {
+  return url
+}
+
+function defaultProbeModule() {
+  return undefined
+}
+
+module.exports = exports = function traverse(
+  entry,
+  opts,
+  readModule,
+  listPrefix,
+  probeModule,
+  resolveModule
+) {
   if (typeof opts === 'function') {
+    resolveModule = probeModule
+    probeModule = listPrefix
     listPrefix = readModule
     readModule = opts
     opts = {}
   }
 
+  if (typeof resolveModule !== 'function') resolveModule = defaultResolveModule
+  if (typeof probeModule !== 'function') probeModule = defaultProbeModule
+
   return {
     *[Symbol.iterator]() {
       const artifacts = { addons: [], assets: [] }
@@ -27,15 +47,9 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
       const visited = opts.visited || new Set()
 
       const queue = [exports.module(entry, null, {}, artifacts, visited, opts)]
-
-      // Asset traversal is deferred until the module graph has been fully
-      // drained so that a module imported both as an asset and as a regular
-      // module is typed by the regular import
       const deferred = []
 
-      while (queue.length > 0 || deferred.length > 0) {
-        const generator = queue.length > 0 ? queue.pop() : deferred.shift()
-
+      function* drive(generator) {
         let next = generator.next()
 
         while (next.done !== true) {
@@ -43,6 +57,10 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
 
           if (value.module) {
             next = generator.next(readModule(value.module))
+          } else if (value.probe) {
+            next = generator.next(probeModule(value.probe))
+          } else if (value.resolution) {
+            next = generator.next(resolveModule(value.resolution))
           } else if (value.prefix) {
             const result = []
 
@@ -57,17 +75,27 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
             }
 
             next = generator.next(result)
+          } else if (value.links) {
+            for (const link of value.links) yield* drive(link)
+
+            next = generator.next()
+          } else if (value.children) {
+            if (value.deferred) deferred.push(value.children)
+            else queue.push(value.children)
+
+            next = generator.next()
           } else {
-            if (value.children) {
-              if (value.deferred) deferred.push(value.children)
-              else queue.push(value.children)
-            } else yield value.dependency
+            yield value.dependency
 
             next = generator.next()
           }
         }
       }
 
+      while (queue.length > 0 || deferred.length > 0) {
+        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+      }
+
       return artifacts
     },
 
@@ -77,15 +105,9 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
       const visited = opts.visited || new Set()
 
       const queue = [exports.module(entry, null, {}, artifacts, visited, opts)]
-
-      // Asset traversal is deferred until the module graph has been fully
-      // drained so that a module imported both as an asset and as a regular
-      // module is typed by the regular import.
       const deferred = []
 
-      while (queue.length > 0 || deferred.length > 0) {
-        const generator = queue.length > 0 ? queue.pop() : deferred.shift()
-
+      async function* drive(generator) {
         let next = generator.next()
 
         while (next.done !== true) {
@@ -93,6 +115,10 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
 
           if (value.module) {
             next = generator.next(await readModule(value.module))
+          } else if (value.probe) {
+            next = generator.next(await probeModule(value.probe))
+          } else if (value.resolution) {
+            next = generator.next(await resolveModule(value.resolution))
           } else if (value.prefix) {
             const result = []
 
@@ -107,17 +133,27 @@ module.exports = exports = function traverse(entry, opts, readModule, listPrefix
             }
 
             next = generator.next(result)
+          } else if (value.links) {
+            for (const link of value.links) yield* drive(link)
+
+            next = generator.next()
+          } else if (value.children) {
+            if (value.deferred) deferred.push(value.children)
+            else queue.push(value.children)
+
+            next = generator.next()
           } else {
-            if (value.children) {
-              if (value.deferred) deferred.push(value.children)
-              else queue.push(value.children)
-            } else yield value.dependency
+            yield value.dependency
 
             next = generator.next()
           }
         }
       }
 
+      while (queue.length > 0 || deferred.length > 0) {
+        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+      }
+
       return artifacts
     }
   }
@@ -147,16 +183,28 @@ exports.alias = function alias(url, opts = {}) {
 }
 
 exports.module = function* (url, source, attributes, artifacts, visited, opts = {}) {
-  const { resolutions = null, asset = false } = opts
+  const { resolutions = null, asset = false, probed } = opts
 
   if (visited.has(url.href)) return false
 
   visited.add(url.href)
 
+  if (probed !== undefined) opts = { ...opts, probed: undefined }
+
+  attributes = attributes || {}
+
+  const artifact = asset === true || moduleType(url, attributes, null, opts) === constants.ADDON
+
   if (source === null) {
-    source = yield { module: url }
+    const exists = probed !== undefined ? probed : artifact ? yield { probe: url } : undefined
 
-    if (source === null) {
+    if (exists === false) {
+      throw errors.MODULE_NOT_FOUND(`Cannot find module '${url.href}'`, url.href)
+    }
+
+    source = yield { module: url, artifact }
+
+    if (exists !== true && source === null) {
       throw errors.MODULE_NOT_FOUND(`Cannot find module '${url.href}'`, url.href)
     }
   }
@@ -167,14 +215,12 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     }
   }
 
-  attributes = attributes || {}
-
   const imports = {}
 
   let info = null
 
   for (const packageURL of lookupPackageScope(url, opts)) {
-    const source = yield { module: packageURL }
+    const source = yield { module: packageURL, artifact: false }
 
     if (source !== null) {
       info = JSON.parse(source)
@@ -193,7 +239,7 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
   if (typeof attributes.imports === 'string') {
     const url = new URL(attributes.imports)
 
-    const source = yield { module: url }
+    const source = yield { module: url, artifact: false }
 
     if (source !== null) {
       opts = {
@@ -207,10 +253,6 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
 
   const lexer = { imports: [], exports: [] }
 
-  // Assets are opaque; their contents are never interpreted, so we only recurse
-  // into modules that are actually imported as modules. An asset that happens
-  // to be a script, module, or addon is not lexed and its imports and addons
-  // are not followed.
   if (asset === false) {
     if (type === constants.SCRIPT || type === constants.MODULE) {
       yield* exports.imports(url, source, imports, artifacts, lexer, visited, opts)
@@ -238,7 +280,7 @@ exports.package = function* (url, source, artifacts, visited, opts = {}) {
   visited.add(url.href)
 
   if (source === null) {
-    source = yield { module: url }
+    source = yield { module: url, artifact: false }
 
     if (source === null) return false
   }
@@ -281,10 +323,10 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
   if (typeof imports !== 'object' || imports === null) return false
 
   for (const [specifier, entry] of Object.entries(imports)) {
-    const stack = [entry]
+    const stack = [{ entry, asset: false }]
 
     while (stack.length > 0) {
-      const entry = stack.pop()
+      const { entry, asset } = stack.pop()
 
       if (typeof entry === 'string') {
         const url = new URL(entry)
@@ -294,6 +336,16 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
             children: exports.package(url, null, artifacts, visited, opts),
             deferred: false
           }
+        } else if (asset) {
+          addURL(artifacts.assets, url)
+
+          yield {
+            children: exports.module(url, null, {}, artifacts, visited, {
+              ...opts,
+              asset: true
+            }),
+            deferred: true
+          }
         } else if (
           url.protocol !== builtinProtocol &&
           url.protocol !== linkedProtocol &&
@@ -305,14 +357,13 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
           }
         }
       } else {
-        stack.unshift(...Object.values(entry))
+        for (const [condition, child] of Object.entries(entry)) {
+          stack.push({ entry: child, asset: asset || condition === 'asset' })
+        }
       }
     }
   }
 
-  // The type is derived from the extension and default type alone; unlike
-  // `module`, the preresolved path does not read the package scope, so any
-  // `package.json` type declaration is not consulted here.
   const type = moduleType(url, {}, null, opts)
 
   const lexer = { imports: [], exports: [] }
@@ -335,22 +386,12 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
 }
 
 exports.imports = function* (parentURL, source, imports, artifacts, lexer, visited, opts = {}) {
-  const {
-    resolve = exports.resolve.default,
-    builtinProtocol = 'builtin:',
-    linkedProtocol = 'linked:',
-    deferredProtocol = 'deferred:',
-    matchedConditions = []
-  } = opts
-
-  let yielded = false
-
-  const queue = []
-
   const lexed = lex(source)
 
   lexer.exports = lexed.exports
 
+  const links = []
+
   for (const entry of lexed.imports) {
     let specifier = entry.specifier
     let condition = 'default'
@@ -366,129 +407,184 @@ exports.imports = function* (parentURL, source, imports, artifacts, lexer, visit
       condition = 'import'
     }
 
-    if (entry.attributes.imports) {
-      const specifier = entry.attributes.imports
-
-      queue.push({
-        entry: {
-          type: 0,
-          specifier,
-          names: [],
-          attributes: {},
-          position: [0, 0, 0]
-        },
-        specifier,
-        condition: 'default'
-      })
-    }
-
     lexer.imports.push(entry)
 
-    queue.push({ entry, specifier, condition })
+    links.push(
+      exports.link(entry, specifier, condition, parentURL, imports, artifacts, visited, opts)
+    )
   }
 
-  while (queue.length > 0) {
-    const { entry, specifier, condition } = queue.shift()
+  yield { links }
+}
+
+exports.link = function* (
+  entry,
+  specifier,
+  condition,
+  parentURL,
+  imports,
+  artifacts,
+  visited,
+  opts = {}
+) {
+  if (entry.attributes.imports) {
+    const specifier = entry.attributes.imports
+
+    yield* resolveImport(
+      { type: 0, specifier, names: [], attributes: {}, position: [0, 0, 0] },
+      specifier,
+      'default',
+      parentURL,
+      imports,
+      artifacts,
+      visited,
+      opts
+    )
+  }
+
+  yield* resolveImport(entry, specifier, condition, parentURL, imports, artifacts, visited, opts)
+}
+
+function* resolveImport(entry, specifier, condition, parentURL, imports, artifacts, visited, opts) {
+  const {
+    resolve = exports.resolve.default,
+    builtinProtocol = 'builtin:',
+    linkedProtocol = 'linked:',
+    deferredProtocol = 'deferred:'
+  } = opts
 
-    matchedConditions.push(condition)
+  const matchedConditions = []
 
-    const resolver = resolve(entry, parentURL, { ...opts, matchedConditions })
-    const candidates = []
+  opts = { ...opts, matchedConditions }
 
-    let next = resolver.next()
-    let resolutions = 0
+  matchedConditions.push(condition)
 
-    while (next.done !== true) {
-      const value = next.value
+  const resolver = resolve(entry, parentURL, opts)
+  const candidates = []
 
-      if (value.package) {
-        next = resolver.next(JSON.parse(yield { module: value.package }))
-      } else {
-        const url = value.resolution
+  let next = resolver.next()
+  let resolutions = 0
 
-        candidates.push(url)
+  while (next.done !== true) {
+    const value = next.value
 
-        let resolved = false
+    if (value.package) {
+      next = resolver.next(JSON.parse(yield { module: value.package, artifact: false }))
+    } else {
+      const url = value.resolution
 
-        if (
-          url.protocol === builtinProtocol ||
-          url.protocol === linkedProtocol ||
-          url.protocol === deferredProtocol
-        ) {
-          addResolution(imports, specifier, matchedConditions, url)
-
-          resolved = yielded = true
-        } else if (condition === 'asset') {
-          const prefix = url
-
-          for (const url of yield { prefix }) {
-            yield {
-              children: exports.module(url, null, {}, artifacts, visited, {
-                ...opts,
-                asset: true
-              }),
-              deferred: true
-            }
+      candidates.push(url)
+
+      let resolved = false
+      let resolution = url
+
+      if (
+        url.protocol === builtinProtocol ||
+        url.protocol === linkedProtocol ||
+        url.protocol === deferredProtocol
+      ) {
+        addResolution(imports, specifier, matchedConditions, url)
 
-            addURL(artifacts.assets, url)
+        resolved = true
+      } else if (condition === 'asset') {
+        const prefix = url
 
-            resolved = yielded = true
+        for (const url of yield { prefix }) {
+          const resolution = yield* postresolve(url)
+
+          yield {
+            children: exports.module(resolution, null, {}, artifacts, visited, {
+              ...opts,
+              asset: true
+            }),
+            deferred: true
           }
 
-          if (resolved) addResolution(imports, specifier, matchedConditions, url)
-        } else {
-          const source = yield { module: url }
+          addURL(artifacts.assets, resolution)
 
-          if (source !== null) {
-            addResolution(imports, specifier, matchedConditions, exports.alias(url, opts))
+          resolved = true
+        }
 
-            let attributes = entry.attributes
+        if (resolved) addResolution(imports, specifier, matchedConditions, url)
+      } else if (
+        condition === 'addon' ||
+        moduleType(url, entry.attributes, null, opts) === constants.ADDON
+      ) {
+        let exists = yield { probe: url }
+        let source = null
 
-            if (attributes.imports) {
-              attributes = { ...attributes, imports: imports[attributes.imports].default }
-            }
+        if (exists === undefined) {
+          source = yield { module: url, artifact: false }
+          exists = source !== null
+        }
 
-            yield {
-              children: exports.module(url, source, attributes, artifacts, visited, opts),
-              deferred: false
-            }
+        if (exists) {
+          resolution = yield* postresolve(url)
 
-            resolved = yielded = true
+          addResolution(imports, specifier, matchedConditions, exports.alias(resolution, opts))
+
+          yield {
+            children: exports.module(resolution, source, {}, artifacts, visited, {
+              ...opts,
+              probed: true
+            }),
+            deferred: false
           }
+
+          resolved = true
         }
+      } else {
+        const source = yield { module: url, artifact: false }
 
-        if (resolved) {
-          if (condition === 'addon') addURL(artifacts.addons, url)
+        if (source !== null) {
+          resolution = yield* postresolve(url)
 
-          resolutions++
-        }
+          addResolution(imports, specifier, matchedConditions, exports.alias(resolution, opts))
 
-        next = resolver.next(resolved)
-      }
-    }
+          let attributes = entry.attributes
 
-    matchedConditions.pop()
+          if (attributes.imports) {
+            attributes = { ...attributes, imports: imports[attributes.imports].default }
+          }
 
-    if (resolutions === 0) {
-      let message = `Cannot find ${condition === 'addon' || condition === 'asset' ? condition : 'module'} '${specifier}' imported from '${parentURL.href}'`
+          yield {
+            children: exports.module(resolution, source, attributes, artifacts, visited, opts),
+            deferred: false
+          }
 
-      if (candidates.length > 0) {
-        message += '\nCandidates:'
-        message += '\n' + candidates.map((url) => '- ' + url.href).join('\n')
+          resolved = true
+        }
       }
 
-      switch (condition) {
-        case 'addon':
-          throw errors.ADDON_NOT_FOUND(message, specifier, parentURL, candidates)
-        case 'asset':
-          throw errors.ASSET_NOT_FOUND(message, specifier, parentURL, candidates)
-        default:
-          throw errors.MODULE_NOT_FOUND(message, specifier, parentURL, candidates)
+      if (resolved) {
+        if (condition === 'addon') addURL(artifacts.addons, resolution)
+
+        resolutions++
       }
+
+      next = resolver.next(resolved)
     }
   }
 
-  return yielded
+  matchedConditions.pop()
+
+  if (resolutions === 0) {
+    let message = `Cannot find ${condition === 'addon' || condition === 'asset' ? condition : 'module'} '${specifier}' imported from '${parentURL.href}'`
+
+    if (candidates.length > 0) {
+      message += '\nCandidates:'
+      message += '\n' + candidates.map((url) => '- ' + url.href).join('\n')
+    }
+
+    switch (condition) {
+      case 'addon':
+        throw errors.ADDON_NOT_FOUND(message, specifier, parentURL, candidates)
+      case 'asset':
+        throw errors.ASSET_NOT_FOUND(message, specifier, parentURL, candidates)
+      default:
+        throw errors.MODULE_NOT_FOUND(message, specifier, parentURL, candidates)
+    }
+  }
 }
 
 const ADDON_EXTENSION = /\.(bare|node)$/
@@ -502,12 +598,14 @@ exports.addons = function* (parentURL, artifacts, visited, opts = {}) {
     prefix.pathname = prefix.pathname.replace(ADDON_EXTENSION, '') + '/'
 
     for (const url of yield { prefix }) {
+      const resolution = yield* postresolve(url)
+
       yield {
-        children: exports.module(url, null, {}, artifacts, visited, opts),
+        children: exports.module(resolution, null, {}, artifacts, visited, opts),
         deferred: false
       }
 
-      addURL(artifacts.addons, url)
+      addURL(artifacts.addons, resolution)
 
       yielded = true
     }
@@ -522,21 +620,19 @@ exports.assets = function* (patterns, parentURL, artifacts, visited, opts = {})
   let yielded = false
 
   for (const url of matches) {
-    const source = yield { module: url }
+    const resolution = yield* postresolve(url)
 
-    if (source !== null) {
-      addURL(artifacts.assets, url)
-
-      yield {
-        children: exports.module(url, source, {}, artifacts, visited, {
-          ...opts,
-          asset: true
-        }),
-        deferred: true
-      }
+    addURL(artifacts.assets, resolution)
 
-      yielded = true
+    yield {
+      children: exports.module(resolution, null, {}, artifacts, visited, {
+        ...opts,
+        asset: true
+      }),
+      deferred: true
     }
+
+    yielded = true
   }
 
   return yielded
@@ -605,10 +701,10 @@ exports.patternMatches = function* patternMatches(pattern, parentURL, matches, o
   return matches
 }
 
-// Determine the module type from an explicit type attribute, if given, and
-// otherwise from the module's extension. For the ambiguous `.js` and `.ts`
-// extensions the nearest `package.json`, passed as `info`, and the default type
-// break the tie. Returns `0` when the type cannot be determined.
+function* postresolve(url) {
+  return (yield { resolution: url }) || url
+}
+
 function moduleType(url, attributes, info, opts = {}) {
   const { defaultType = constants.SCRIPT, aliases = null } = opts
 
@@ -635,7 +731,7 @@ function moduleType(url, attributes, info, opts = {}) {
 
   const match = url.pathname.match(/\.[a-z]+$/)
 
-  if (match === null) return 0
+  if (match === null) return defaultType
 
   let [extension] = match
 
@@ -666,7 +762,7 @@ function moduleType(url, attributes, info, opts = {}) {
       return constants.TEXT
   }
 
-  return 0
+  return defaultType
 }
 
 function addURL(collection, url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-module-traverse",
-  "version": "2.3.1",
+  "version": "2.4.1",
   "description": "Low-level module graph traversal for Bare",
   "exports": {
     ".": {