bare-module-traverse 2.5.9 → 2.7.0

package/README.md

@@ -219,12 +219,16 @@ Options are the same as `traverse()` for all functions.
 
 ### `const generator = traverse.package(url, source, artifacts, visited[, options])`
 
-### `const generator = traverse.preresolved(url, source, resolutions, artifacts, visited[, options])`
+### `const generator = traverse.preresolved(url, source, attributes, resolutions, 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])`
 
+### `traverse.assertAddonContext(url, scope, context, addonContexts)`
+
+Record in `addonContexts` that the package at `scope` loads its addons in `context`, an object of the `host` and the URL of the `wasi` provider, either `null` for the defaults. Throws if it was recorded for another context, or if `url` doesn't load on `context.host`.
+
 ### `const generator = traverse.addons(parentURL, artifacts, visited[, options])`
 
 ### `const generator = traverse.assets(patterns, parentURL, artifacts, visited[, options])`

package/index.d.ts

@@ -3,9 +3,10 @@ import Buffer from 'bare-buffer'
 import {
   type ConditionalSpecifier,
   type ImportsMap,
-  type ResolutionsMap
+  type ResolutionsMap,
+  type ResolveOptions as ModuleResolveOptions
 } from 'bare-module-resolve'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 import { type Import, type Export } from 'bare-module-lexer'
 
 interface Dependency {
@@ -41,6 +42,8 @@ type AliasableExtension =
   | '.bin'
   | '.txt'
 
+interface ResolveOptions extends ModuleResolveOptions, AddonResolveOptions {}
+
 interface TraverseOptions extends ResolveOptions {
   /**
    * The type to assume for a module that has no type of its own, such as one
@@ -174,9 +177,22 @@ declare namespace traverse {
     opts?: TraverseOptions
   ): Traversal
 
+  interface AddonContext {
+    host: string | null
+    wasi: string | null
+  }
+
+  export function assertAddonContext(
+    url: URL,
+    scope: string,
+    context: Partial<AddonContext>,
+    addonContexts: Map<string, AddonContext>
+  ): void
+
   export function preresolved(
     url: URL,
     source: string | Buffer,
+    attributes: Record<string, string> | null,
     resolution: ResolutionsMap,
     artifacts: Artifacts,
     visited: Set<string>,

package/index.js

@@ -98,7 +98,7 @@ module.exports = exports = function traverse(
       }
 
       while (queue.length > 0 || deferred.length > 0) {
-        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+        yield* drive(queue.length > 0 ? queue.shift() : deferred.shift())
       }
 
       return artifacts
@@ -160,7 +160,7 @@ module.exports = exports = function traverse(
       }
 
       while (queue.length > 0 || deferred.length > 0) {
-        yield* drive(queue.length > 0 ? queue.pop() : deferred.shift())
+        yield* drive(queue.length > 0 ? queue.shift() : deferred.shift())
       }
 
       return artifacts
@@ -192,10 +192,36 @@ exports.alias = function alias(url, opts = {}) {
 }
 
 exports.module = function* (url, source, attributes, artifacts, visited, opts = {}) {
-  const { resolutions = null, asset = false, probed, types } = opts
-
   attributes = attributes || {}
 
+  if (opts.contexts === undefined) opts = { ...opts, contexts: new Map() }
+  if (opts.addonContexts === undefined) opts = { ...opts, addonContexts: new Map() }
+  if (opts.resolvedImports === undefined) opts = { ...opts, resolvedImports: new Map() }
+
+  // The host and WASI attributes set the context that the addons of the module
+  // and everything it imports load in. A graph is walked again for each context
+  // it is imported under, even where it was visited before. The conditions of
+  // the host are added to those that may be targeted, so that the order of the
+  // conditions in a package still decides between them and the native ones.
+  if (attributes.host !== undefined || attributes.wasi !== undefined) {
+    const { addonHost = null, addonWASI = null } = opts
+
+    const host = attributes.host === undefined ? addonHost : addonHostForAttribute(attributes.host)
+    const wasi = attributes.wasi === undefined ? addonWASI : attributes.wasi
+
+    if (host !== addonHost || wasi !== addonWASI) {
+      opts = { ...opts, addonHost: host, addonWASI: wasi }
+
+      if (host !== addonHost) {
+        opts.conditions = withConditions(opts.conditions, host.split('-'))
+      }
+
+      visited = visitedFor(opts.contexts, host, wasi)
+    }
+  }
+
+  const { resolutions = null, asset = false, probed, types } = opts
+
   if (visited.has(url.href)) {
     // An asset is only read for its bytes, so it doesn't care what type the
     // module is imported as elsewhere.
@@ -214,7 +240,9 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
   if (opts.prefixes === undefined) opts = { ...opts, prefixes: new Map() }
   if (opts.types === undefined) opts = { ...opts, types: new Map() }
 
-  const artifact = asset === true || moduleType(url, attributes, null, opts) === constants.ADDON
+  const artifact =
+    asset === true ||
+    (moduleType(url, attributes, null, opts) === constants.ADDON && !isWebAssembly(url))
 
   if (source === null) {
     if (url.protocol === 'data:') {
@@ -234,8 +262,17 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     }
   }
 
-  if (resolutions) {
-    if (yield* exports.preresolved(url, source, resolutions, artifacts, visited, opts)) {
+  // A module resolves its imports once, however many contexts it is loaded in,
+  // so a context that reaches it after another walks what the other resolved.
+  // The addons that are reached are then checked against the context.
+  const resolved = opts.resolvedImports.get(url.href)
+
+  const preresolved = resolved === undefined ? resolutions : { [url.href]: resolved }
+
+  if (preresolved) {
+    if (
+      yield* exports.preresolved(url, source, attributes, preresolved, artifacts, visited, opts)
+    ) {
       return true
     }
   }
@@ -290,15 +327,22 @@ exports.module = function* (url, source, attributes, artifacts, visited, opts =
     }
   }
 
+  const compressed = compressImportsMap(imports)
+
+  opts.resolvedImports.set(url.href, compressed)
+
   yield {
-    dependency: {
-      url: exports.alias(url, opts),
-      source,
-      type,
-      naturalType,
-      imports: compressImportsMap(imports),
-      lexer
-    }
+    dependency: withWASI(
+      {
+        url: exports.alias(url, opts),
+        source,
+        type,
+        naturalType,
+        imports: compressed,
+        lexer
+      },
+      opts
+    )
   }
 
   return true
@@ -342,7 +386,15 @@ exports.package = function* (url, source, artifacts, visited, opts = {}) {
   return false
 }
 
-exports.preresolved = function* (url, source, resolutions, artifacts, visited, opts = {}) {
+exports.preresolved = function* (
+  url,
+  source,
+  attributes,
+  resolutions,
+  artifacts,
+  visited,
+  opts = {}
+) {
   const {
     builtinProtocol = 'builtin:',
     linkedProtocol = 'linked:',
@@ -353,6 +405,17 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
 
   if (typeof imports !== 'object' || imports === null) return false
 
+  attributes = attributes || {}
+
+  const parentURL = url
+
+  // The resolutions map leaves out the import attributes, so they are read
+  // from the source instead.
+  const lexed =
+    opts.asset !== true && isJavaScript(moduleType(url, attributes, null, opts))
+      ? lex(source)
+      : null
+
   let info = null
 
   for (const [specifier, entry] of Object.entries(imports)) {
@@ -382,7 +445,11 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
         } else if (url.protocol === deferredProtocol) {
           continue
         } else if (url.protocol === builtinProtocol || url.protocol === linkedProtocol) {
-          if (addon && artifacts !== null) addURL(artifacts.addons, url)
+          if (addon) {
+            assertImportedAddonContext(url, imports, parentURL, opts)
+
+            if (artifacts !== null) addURL(artifacts.addons, url)
+          }
         } else if (asset) {
           if (artifacts !== null) {
             const expanded = yield* expandAsset(url, artifacts, visited, { ...opts, importType: 0 })
@@ -402,13 +469,24 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
             }
           }
         } else {
-          if (addon && artifacts !== null) addURL(artifacts.addons, url)
+          if (addon) {
+            assertImportedAddonContext(url, imports, parentURL, opts)
+
+            if (artifacts !== null) addURL(artifacts.addons, url)
+          }
 
           yield {
-            children: exports.module(url, null, {}, artifacts, visited, {
-              ...opts,
-              importType: 0
-            }),
+            children: exports.module(
+              url,
+              null,
+              addon ? { type: 'addon' } : importAttributes(lexed, specifier, imports),
+              artifacts,
+              visited,
+              {
+                ...opts,
+                importType: 0
+              }
+            ),
             deferred: false
           }
         }
@@ -424,26 +502,27 @@ exports.preresolved = function* (url, source, resolutions, artifacts, visited, o
     }
   }
 
-  const type = moduleType(url, {}, info, opts)
+  const type = moduleType(url, attributes, info, opts)
 
   const lexer = { imports: [], exports: [] }
 
-  if (opts.asset !== true && (type === constants.SCRIPT || type === constants.MODULE)) {
-    const lexed = lex(source)
-
+  if (lexed !== null && isJavaScript(type)) {
     lexer.imports = lexed.imports
     lexer.exports = lexed.exports
   }
 
   yield {
-    dependency: {
-      url: exports.alias(url, opts),
-      source,
-      type,
-      naturalType: type,
-      imports: compressImportsMap(imports),
-      lexer
-    }
+    dependency: withWASI(
+      {
+        url: exports.alias(url, opts),
+        source,
+        type,
+        naturalType: naturalModuleType(url, attributes, info, type, opts),
+        imports: compressImportsMap(imports),
+        lexer
+      },
+      opts
+    )
   }
 
   return true
@@ -491,8 +570,10 @@ exports.link = function* (
   visited,
   opts = {}
 ) {
-  if (entry.attributes.imports) {
-    const specifier = entry.attributes.imports
+  for (const name of ['imports', 'wasi']) {
+    const specifier = entry.attributes[name]
+
+    if (!specifier) continue
 
     yield* resolveImport(
       { type: 0, specifier, names: [], attributes: {}, position: [0, 0, 0] },
@@ -515,7 +596,8 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
     builtinProtocol = 'builtin:',
     linkedProtocol = 'linked:',
     deferredProtocol = 'deferred:',
-    deferUnresolved = false
+    deferUnresolved = false,
+    loadable = null
   } = opts
 
   const matchedConditions = []
@@ -524,7 +606,11 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
 
   matchedConditions.push(condition)
 
-  const resolver = resolve(entry, parentURL, opts)
+  const resolver = resolve(
+    entry,
+    parentURL,
+    condition === 'addon' && opts.addonHost ? { ...opts, hosts: [opts.addonHost] } : opts
+  )
   const candidates = []
 
   let next = resolver.next()
@@ -548,6 +634,8 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
         url.protocol === linkedProtocol ||
         url.protocol === deferredProtocol
       ) {
+        if (condition === 'addon') assertImportedAddonContext(url, imports, parentURL, opts)
+
         addResolution(imports, specifier, matchedConditions, url)
 
         resolved = true
@@ -565,7 +653,7 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
         condition === 'addon' ||
         moduleType(url, entry.attributes, null, opts) === constants.ADDON
       ) {
-        let exists = yield { probe: url }
+        let exists = isWebAssembly(url) ? undefined : yield { probe: url }
         let source = null
 
         if (exists === undefined) {
@@ -573,13 +661,15 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
           exists = source !== null
         }
 
-        if (exists) {
-          resolution = yield* postresolve(url)
+        if (exists) resolution = yield* postresolve(url)
+
+        if (exists && (loadable === null || loadable(resolution))) {
+          assertImportedAddonContext(resolution, imports, parentURL, opts)
 
           addResolution(imports, specifier, matchedConditions, exports.alias(resolution, opts))
 
           yield {
-            children: exports.module(resolution, source, {}, artifacts, visited, {
+            children: exports.module(resolution, source, { type: 'addon' }, artifacts, visited, {
               ...opts,
               probed: true
             }),
@@ -608,6 +698,10 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
             attributes = { ...attributes, imports: imports[attributes.imports].default }
           }
 
+          if (attributes.wasi) {
+            attributes = { ...attributes, wasi: imports[attributes.wasi].default }
+          }
+
           yield {
             children: exports.module(resolution, source, attributes, artifacts, visited, {
               ...opts,
@@ -657,7 +751,115 @@ function* resolveImport(entry, specifier, condition, parentURL, imports, artifac
   }
 }
 
-const ADDON_EXTENSION = /\.(bare|node)$/
+const ADDON_EXTENSION = /\.(bare|node|wasm)$/
+
+function importAttributes(lexed, specifier, imports) {
+  const attributes = {}
+
+  if (lexed === null) return attributes
+
+  for (const entry of lexed.imports) {
+    if (entry.specifier !== specifier) continue
+
+    for (const name of ['type', 'host', 'wasi']) {
+      if (typeof entry.attributes[name] === 'string') attributes[name] = entry.attributes[name]
+    }
+  }
+
+  if (attributes.wasi !== undefined) attributes.wasi = defaultResolution(imports[attributes.wasi])
+
+  return attributes
+}
+
+function defaultResolution(entry) {
+  return typeof entry === 'string' ? entry : entry.default
+}
+
+// Only hosts that load on any platform may be asked for, so that an import
+// can't pick the native addons of another platform.
+const portableHosts = ['wasi-wasm32']
+
+function addonHostForAttribute(host) {
+  if (portableHosts.includes(host)) return host
+
+  throw errors.UNKNOWN_ADDON_HOST(`Addon host '${host}' is not supported`)
+}
+
+function withConditions(conditions = [], added) {
+  if (conditions.every((condition) => typeof condition === 'string')) {
+    return [...conditions, ...added]
+  }
+
+  return conditions.map((subset) => withConditions(subset, added))
+}
+
+function visitedFor(contexts, host, wasi) {
+  const key = JSON.stringify([host, wasi])
+
+  let context = contexts.get(key)
+
+  if (context === undefined) contexts.set(key, (context = { host, wasi, visited: new Set() }))
+
+  return context.visited
+}
+
+function withWASI(dependency, opts) {
+  const { addonWASI = null } = opts
+
+  if (addonWASI !== null && dependency.type === constants.ADDON && isWebAssembly(dependency.url)) {
+    dependency.wasi = addonWASI
+  }
+
+  return dependency
+}
+
+function assertImportedAddonContext(url, imports, parentURL, opts) {
+  const { addonHost = null, addonWASI = null, addonContexts } = opts
+
+  exports.assertAddonContext(
+    url,
+    imports['#package'] || parentURL.href,
+    { host: addonHost, wasi: addonWASI },
+    addonContexts
+  )
+}
+
+exports.assertAddonContext = function assertAddonContext(url, scope, context, addonContexts) {
+  if (url.protocol === 'builtin:') return
+
+  const { host = null } = context
+
+  if (host !== null && !isWebAssembly(url)) {
+    throw errors.ADDON_HOST_INCOMPATIBLE(
+      `Addon '${url.href}' is not a WebAssembly addon, but '${host}' was asked for`
+    )
+  }
+
+  // Only WebAssembly addons are given WASI capabilities.
+  const wasi = isWebAssembly(url) ? context.wasi || null : null
+
+  const recorded = addonContexts.get(scope)
+
+  if (recorded === undefined) {
+    addonContexts.set(scope, { host, wasi })
+  } else if (recorded.host !== host) {
+    throw errors.ADDON_HOST_INCOMPATIBLE(
+      `Addons of '${scope}' are already resolved for ${recorded.host === null ? 'the default hosts' : `'${recorded.host}'`}`
+    )
+  } else if (recorded.wasi !== wasi) {
+    throw errors.ADDON_WASI_INCOMPATIBLE(
+      `Addons of '${scope}' are already given ${recorded.wasi === null ? 'the default WASI capabilities' : `the WASI capabilities of '${recorded.wasi}'`}`
+    )
+  }
+}
+
+function isJavaScript(type) {
+  return type === constants.SCRIPT || type === constants.MODULE
+}
+
+function isWebAssembly(url) {
+  return url.pathname.endsWith('.wasm')
+}
 
 exports.addons = function* (parentURL, artifacts, visited, opts = {}) {
   let yielded = false

package/lib/conditions.js

@@ -0,0 +1,23 @@
+// One set of conditions for each host, each with the targeted conditions. A
+// host whose conditions are targeted in every set already has its resolutions,
+// so it gets no set of its own.
+module.exports = function conditions(base, hosts, targets) {
+  const subsets = leaves(targets)
+
+  const own = hosts.filter(
+    (host) =>
+      !subsets.every((subset) => host.split('-').every((condition) => subset.includes(condition)))
+  )
+
+  return (own.length > 0 ? own : hosts).flatMap((host) =>
+    subsets.map((subset) => [...base, ...host.split('-'), ...subset])
+  )
+}
+
+// Conditions nest to any depth and are tried depth first, so they match as
+// their innermost lists would in order.
+function leaves(conditions) {
+  if (conditions.every((condition) => typeof condition === 'string')) return [conditions]
+
+  return conditions.flatMap(leaves)
+}

package/lib/errors.js

@@ -49,6 +49,18 @@ module.exports = class ModuleTraverseError extends Error {
     return new ModuleTraverseError(msg, ModuleTraverseError.TYPE_INCOMPATIBLE)
   }
 
+  static UNKNOWN_ADDON_HOST(msg) {
+    return new ModuleTraverseError(msg, ModuleTraverseError.UNKNOWN_ADDON_HOST)
+  }
+
+  static ADDON_HOST_INCOMPATIBLE(msg) {
+    return new ModuleTraverseError(msg, ModuleTraverseError.ADDON_HOST_INCOMPATIBLE)
+  }
+
+  static ADDON_WASI_INCOMPATIBLE(msg) {
+    return new ModuleTraverseError(msg, ModuleTraverseError.ADDON_WASI_INCOMPATIBLE)
+  }
+
   static AMBIGUOUS_MODULE_TYPE(msg) {
     return new ModuleTraverseError(msg, ModuleTraverseError.AMBIGUOUS_MODULE_TYPE)
   }

package/lib/resolve/bare.d.ts

@@ -1,10 +1,17 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type Conditions, type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 
-interface BareResolveOptions extends ResolveOptions {
+interface BareResolveOptions extends ModuleResolveOptions, AddonResolveOptions {
   linked?: boolean
   host?: string
   hosts?: string[]
+  /**
+   * The conditions that may be targeted in addition to those of each host,
+   * either a list or nested lists to try in turn.
+   */
+  conditions?: Conditions
 }
 
 /**

package/lib/resolve/bare.js

@@ -1,13 +1,19 @@
 const lex = require('bare-module-lexer')
 const resolve = require('../resolve')
 const runtime = require('../runtime')
+const hostConditions = require('../conditions')
 
 module.exports = function (entry, parentURL, opts = {}) {
-  const { linked = false, host = runtime.host, hosts = [host] } = opts
+  const {
+    linked = false,
+    host = runtime.host,
+    hosts = [host, 'wasi-wasm32'],
+    conditions: targets = []
+  } = opts
 
   let directories = false
   let extensions
-  let conditions = hosts.map((host) => ['bare', 'node', ...host.split('-')])
+  let conditions = hostConditions(['bare', 'node'], hosts, targets)
 
   if (entry.type & lex.constants.ADDON) {
     extensions = linked ? [] : ['.bare', '.node']

package/lib/resolve/default.d.ts

@@ -1,5 +1,9 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
+
+interface ResolveOptions extends ModuleResolveOptions, AddonResolveOptions {}
 
 /**
  * @param entry - The import to resolve, as produced by `bare-module-lexer`.

package/lib/resolve/node.d.ts

@@ -1,9 +1,16 @@
+import URL from 'bare-url'
 import { type Import } from 'bare-module-lexer'
-import { type ResolveOptions, type Resolver } from 'bare-addon-resolve'
+import { type Conditions, type ResolveOptions as ModuleResolveOptions } from 'bare-module-resolve'
+import { type ResolveOptions as AddonResolveOptions, type Resolver } from 'bare-addon-resolve'
 
-interface NodeResolveOptions extends ResolveOptions {
+interface NodeResolveOptions extends ModuleResolveOptions, AddonResolveOptions {
   host?: string
   hosts?: string[]
+  /**
+   * The conditions that may be targeted in addition to those of each host,
+   * either a list or nested lists to try in turn.
+   */
+  conditions?: Conditions
 }
 
 /**

package/lib/resolve/node.js

@@ -1,13 +1,14 @@
 const lex = require('bare-module-lexer')
 const resolve = require('../resolve')
 const runtime = require('../runtime')
+const hostConditions = require('../conditions')
 
 module.exports = function (entry, parentURL, opts = {}) {
-  const { host = runtime.host, hosts = [host] } = opts
+  const { host = runtime.host, hosts = [host], conditions: targets = [] } = opts
 
   let directories = false
   let extensions
-  let conditions = hosts.map((host) => ['node', ...host.split('-')])
+  let conditions = hostConditions(['node'], hosts, targets)
 
   if (entry.type & lex.constants.ADDON) {
     extensions = ['.node']

package/package.json

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