The lib basis includes which libraries and versions were loaded both
for direct dependencies and transitive dependencies, as well as the
classpath and possibly other information from the resolution process.
This basis will be known if the runtime was started by the Clojure CLI.

The Clojure CLI or tools.deps merge a set of deps maps (often from
deps.edn files). Additional runtime modifications are supplied via argmap
keys, provided via alias maps in the merged deps. Deps maps typically have
:paths, :deps, and :aliases keys.

The basis is a superset of merged deps.edn files with the following
additional keys:
  :basis-config - params used to configure basis deps sources, can be
                  string path, deps map, nil, or :default
    :root - default = loaded as a resource from tools.deps)
    :user - default = ~/.clojure/deps.edn)
    :project - default = ./deps.edn)
    :extra - default = nil
    :aliases - coll of keyword aliases to include during dep calculation
  :argmap - effective argmap (after resolving and merging argmaps from aliases)
  :libs - map of lib to coord for all included libraries
  :classpath - classpath map, keys are paths (to directory or .jar), values
               are maps with source identifier (either :lib-name or :path-key)
  :classpath-roots - vector of paths in classpath order (keys of :classpath)

Start a web browser from Clojure

Helper namespace for clojure.java.browse.
Prevents console apps from becoming GUI unnecessarily.

This file defines polymorphic I/O utility functions for Clojure.

A repl helper to quickly open javadocs.

A process invocation API wrapping the Java process API.

The primary function here is 'start' which starts a process and handles the
streams as directed. It returns a map that contains keys to access the streams
(if available) and the Java Process object. It is also deref-able to wait for
process exit.

Helper functions are available to 'capture' the output of the process stdout
and to wait for an 'ok?' non-error exit. The 'exec' function handles the common
case of `start'ing a process, waiting for process exit, capture and return
stdout.

Conveniently launch a sub-process providing its stdin and
collecting its stdout