@form8ion/javascript 14.0.0-alpha.9 → 14.0.0-beta.1

package/lib/index.js

@@ -1,12 +1,12 @@
 import { questionNames as questionNames$2, questions } from '@travi/language-scaffolder-prompts';
 import deepmerge from 'deepmerge';
-import { fileTypes, fileExists, optionsSchemas, validateOptions, loadConfigFile, applyEnhancers, writeConfigFile } from '@form8ion/core';
-import { scaffoldChoice, writePackageJson, packageManagers as packageManagers$1, projectTypes as projectTypes$1, mergeIntoExistingPackageJson, dialects as dialects$1, DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE } from '@form8ion/javascript-core';
+import { fileTypes, fileExists, optionsSchemas, validateOptions, loadConfigFile, writeConfigFile, applyEnhancers } from '@form8ion/core';
+import { scaffoldChoice, dialects as dialects$1, projectTypes as projectTypes$1, packageManagers as packageManagers$1, writePackageJson, DEV_DEPENDENCY_TYPE, PROD_DEPENDENCY_TYPE, mergeIntoExistingPackageJson } from '@form8ion/javascript-core';
 import { prompt as prompt$1 } from '@form8ion/overridable-prompts';
 import joi from 'joi';
 import { scaffold, lift as lift$3 } from '@form8ion/codecov';
 import { write as write$2 } from '@form8ion/config-file';
-import { info, warn, error } from '@travi/cli-messages';
+import { warn, info, error } from '@travi/cli-messages';
 import * as commitConventionPlugin from '@form8ion/commit-convention';
 import { scaffold as scaffold$4 } from '@form8ion/commit-convention';
 import { execa } from 'execa';
@@ -21,12 +21,12 @@ import camelcase from 'camelcase';
 import { resolve } from 'path';
 import filedirname from 'filedirname';
 import * as huskyPlugin from '@form8ion/husky';
-import { scaffold as scaffold$3 } from '@form8ion/husky';
+import { scaffold as scaffold$1 } from '@form8ion/husky';
 import { promises as promises$1 } from 'node:fs';
 import { stringify, parse } from 'ini';
-import { scaffold as scaffold$2 } from '@form8ion/prettier';
+import { scaffold as scaffold$3 } from '@form8ion/prettier';
 import * as eslintPlugin from '@form8ion/eslint';
-import { scaffold as scaffold$1, test as test$1 } from '@form8ion/eslint';
+import { scaffold as scaffold$2, test as test$1 } from '@form8ion/eslint';
 import sortProperties from 'sort-object-keys';
 
 const questionNames$1 = {
@@ -157,189 +157,357 @@ async function scaffoldUnitTesting ({projectRoot, frameworks, decisions, visibil
   ]);
 }
 
-function tester$4 () {
-  return true;
-}
-
-function buildAllowedHostsList ({packageManager, registries = {}}) {
-  return [
-    ...!registries.registry ? [packageManager] : [],
-    ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
-  ];
-}
-
-async function scaffoldNpm ({projectRoot}) {
-  const [packageContents, {stdout}] = await Promise.all([
-    promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'),
-    execa('npm', ['--version'])
-  ]);
-  const existingPackageJsonContents = JSON.parse(packageContents);
-
-  await writePackageJson({
-    projectRoot,
-    config: {
-      ...existingPackageJsonContents,
-      packageManager: `npm@${stdout}`
-    }
-  });
-}
+const scopeBasedConfigSchema = joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()});
 
-function determineLockfilePathFor (packageManager) {
-  const lockfilePaths = {
-    [packageManagers$1.NPM]: 'package-lock.json',
-    [packageManagers$1.YARN]: 'yarn.lock'
-  };
+const nameBasedConfigSchema = joi.object({
+  packageName: joi.string().required(),
+  name: joi.string().required()
+});
 
-  return lockfilePaths[packageManager];
-}
+const registriesSchema = joi.object().pattern(joi.string(), joi.string().uri()).default({});
 
-function npmIsUsed ({projectRoot, pinnedPackageManager = ''}) {
-  const [packageManager] = pinnedPackageManager.split('@');
+const visibilitySchema = joi.string().valid('Public', 'Private').required();
 
-  return packageManagers$1.NPM === packageManager
-    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.NPM)}`);
-}
+const projectNameSchema = joi.string().regex(/^@\w*\//, {invert: true}).required();
 
-async function scaffoldYarn ({projectRoot}) {
-  const [packageContents, {stdout}] = await Promise.all([
-    promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'),
-    execa('yarn', ['--version'])
-  ]);
-  const existingPackageJsonContents = JSON.parse(packageContents);
+const vcsSchema = joi.object({
+  host: joi.string().required(),
+  owner: joi.string().required(),
+  name: joi.string().required()
+});
 
-  await writePackageJson({
-    projectRoot,
-    config: {
-      ...existingPackageJsonContents,
-      packageManager: `yarn@${stdout}`
+function validate(options) {
+  const schema = joi.object({
+    projectRoot: joi.string().required(),
+    projectName: projectNameSchema,
+    visibility: visibilitySchema,
+    license: joi.string().required(),
+    description: joi.string(),
+    pathWithinParent: joi.string(),
+    decisions: joi.object(),
+    vcs: vcsSchema,
+    configs: joi.object({
+      eslint: scopeBasedConfigSchema,
+      typescript: scopeBasedConfigSchema,
+      prettier: scopeBasedConfigSchema,
+      commitlint: nameBasedConfigSchema,
+      babelPreset: nameBasedConfigSchema,
+      remark: joi.string(),
+      registries: registriesSchema
+    }).default({registries: {}}),
+    plugins: {
+      unitTestFrameworks: pluginsSchema,
+      packageBundlers: pluginsSchema,
+      applicationTypes: pluginsSchema,
+      packageTypes: pluginsSchema,
+      monorepoTypes: pluginsSchema,
+      hosts: pluginsSchema,
+      ciServices: pluginsSchema
     }
-  });
-}
-
-function yarnIsUsed ({projectRoot, pinnedPackageManager = ''}) {
-  const [packageManager] = pinnedPackageManager.split('@');
+  }).required();
 
-  return packageManagers$1.YARN === packageManager
-    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.YARN)}`);
+  return validateOptions(schema, options);
 }
 
-async function jsPackageManagerIsUsed ({projectRoot}) {
-  const [npmFound, yarnFound] = await Promise.all([
-    npmIsUsed({projectRoot}),
-    yarnIsUsed({projectRoot})
-  ]);
-
-  return npmFound || yarnFound;
+function buildDialectChoices ({babelPreset, typescript}) {
+  return [
+    {name: 'Common JS (no transpilation)', value: dialects$1.COMMON_JS, short: 'cjs'},
+    ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: dialects$1.BABEL, short: 'modern'}] : [],
+    {name: 'ESM-only (no transpilation)', value: dialects$1.ESM, short: 'esm'},
+    ...typescript ? [{name: 'TypeScript', value: dialects$1.TYPESCRIPT, short: 'ts'}] : []
+  ];
 }
 
-async function liftCorepack () {
-  await execa('corepack', ['use', 'npm@latest']);
+function projectIsCLI(answers) {
+  return projectTypes$1.CLI === answers[questionNames$1.PROJECT_TYPE];
 }
 
-async function lifter$5 () {
-  await liftCorepack();
-
-  return {};
+function projectIsPackage(answers) {
+  return projectTypes$1.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
 }
 
-const scaffolders = {
-  npm: scaffoldNpm,
-  yarn: scaffoldYarn
-};
-
-function scaffoldPackageManager ({projectRoot, packageManager}) {
-  return scaffolders[packageManager]({projectRoot});
+function projectIsApplication(answers) {
+  return projectTypes$1.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
 }
 
-async function resolvePackageManager ({projectRoot, packageManager}) {
-  if (packageManager) return packageManager;
-
-  const {packageManager: pinnedPackageManager} = JSON.parse(await promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'));
-
-  if (await npmIsUsed({projectRoot, pinnedPackageManager})) {
-    return packageManagers$1.NPM;
-  }
-
-  if (await yarnIsUsed({projectRoot, pinnedPackageManager})) {
-    return packageManagers$1.YARN;
-  }
-
-  throw new Error('Package-manager could not be determined');
+function packageShouldBeScoped(visibility, answers) {
+  return 'Private' === visibility || answers[questionNames$1.SHOULD_BE_SCOPED];
 }
 
-var packageManagers = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  defineLockfilePath: determineLockfilePathFor,
-  determineCurrent: resolvePackageManager,
-  lift: lifter$5,
-  scaffold: scaffoldPackageManager,
-  test: jsPackageManagerIsUsed
-});
-
-const lockfileLintSupportedPackageManagers = [packageManagers$1.NPM, packageManagers$1.YARN];
-
-function lockfileLintSupports(packageManager) {
-  return lockfileLintSupportedPackageManagers.includes(packageManager);
+function willBePublishedToNpm(answers) {
+  return projectIsPackage(answers) || projectIsCLI(answers);
 }
 
-async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
-  if (!lockfileLintSupports(packageManager)) {
-    throw new Error(
-      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
-      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
-    );
-  }
-
-  await write$2({
-    name: 'lockfile-lint',
-    format: fileTypes.JSON,
-    path: projectRoot,
-    config: {
-      path: determineLockfilePathFor(packageManager),
-      type: packageManager,
-      'validate-https': true,
-      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
-    }
-  });
-
-  return {
-    dependencies: {javascript: {development: ['lockfile-lint']}},
-    scripts: {'lint:lockfile': 'lockfile-lint'}
-  };
+function shouldBeScopedPromptShouldBePresented(answers) {
+  return willBePublishedToNpm(answers);
 }
 
-function lockfileLintIsAlreadyConfigured ({projectRoot}) {
-  return fileExists(`${projectRoot}/.lockfile-lintrc.json`);
+function scopePromptShouldBePresentedFactory(visibility) {
+  return answers => willBePublishedToNpm(answers) && packageShouldBeScoped(visibility, answers);
 }
 
-const configName = 'lockfile-lint';
-
-function read({projectRoot}) {
-  return loadConfigFile({name: `.${configName}rc`, format: fileTypes.JSON, path: projectRoot});
+function lintingPromptShouldBePresented({
+  [questionNames$2.UNIT_TESTS]: unitTested,
+  [questionNames$2.INTEGRATION_TESTS]: integrationTested
+}) {
+  return !unitTested && !integrationTested;
 }
 
-function write$1({projectRoot, config}) {
-  return write$2({name: configName, format: fileTypes.JSON, path: projectRoot, config});
-}
+function scope(visibility) {
+  return input => {
+    if (!input && 'Private' === visibility) {
+      return 'Private packages must be scoped (https://docs.npmjs.com/private-modules/intro#setting-up-your-package)';
+    }
 
-async function writeNpmConfig ({projectRoot, config}) {
-  await promises$1.writeFile(`${projectRoot}/.npmrc`, stringify(config));
+    return true;
+  };
 }
 
-function projectWillNotBeConsumed(projectType) {
-  return projectTypes$1.APPLICATION === projectType || projectTypes$1.CLI === projectType;
+function authorQuestions({name, email, url}) {
+  return [
+    {
+      name: questionNames$1.AUTHOR_NAME,
+      message: 'What is the author\'s name?',
+      default: name
+    },
+    {
+      name: questionNames$1.AUTHOR_EMAIL,
+      message: 'What is the author\'s email?',
+      default: email
+    },
+    {
+      name: questionNames$1.AUTHOR_URL,
+      message: 'What is the author\'s website url?',
+      default: url
+    }
+  ];
 }
 
-async function scaffoldNpmConfig ({projectRoot, projectType}) {
-  await writeNpmConfig({
-    projectRoot,
-    config: {'update-notifier': false, ...projectWillNotBeConsumed(projectType) && {'save-exact': true}}
-  });
+async function prompt(
+  ciServices,
+  hosts,
+  visibility,
+  vcs,
+  decisions,
+  configs,
+  pathWithinParent
+) {
+  const npmConf$1 = npmConf();
 
-  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
-}
+  let maybeLoggedInNpmUsername;
+  try {
+    maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
+  } catch (failedExecutionResult) {
+    if (!decisions[questionNames$1.SCOPE]) {
+      warn('No logged in user found with `npm whoami`. Login with `npm login` '
+        + 'to use your npm account name as the package scope default.');
+    }
+  }
 
-function tester$3 ({projectRoot}) {
+  const {
+    [questionNames$2.UNIT_TESTS]: unitTested,
+    [questionNames$2.INTEGRATION_TESTS]: integrationTested,
+    [questionNames$1.PROJECT_TYPE]: projectType,
+    [questionNames$2.CI_SERVICE]: ci,
+    [questionNames$1.HOST]: chosenHost,
+    [questionNames$1.SCOPE]: scope$1,
+    [questionNames$1.NODE_VERSION_CATEGORY]: nodeVersionCategory,
+    [questionNames$1.AUTHOR_NAME]: authorName,
+    [questionNames$1.AUTHOR_EMAIL]: authorEmail,
+    [questionNames$1.AUTHOR_URL]: authorUrl,
+    [questionNames$1.CONFIGURE_LINTING]: configureLinting,
+    [questionNames$1.PROVIDE_EXAMPLE]: provideExample,
+    [questionNames$1.PACKAGE_MANAGER]: packageManager,
+    [questionNames$1.DIALECT]: dialect
+  } = await prompt$1([
+    {
+      name: questionNames$1.DIALECT,
+      message: 'Which JavaScript dialect should this project follow?',
+      type: 'list',
+      choices: buildDialectChoices(configs),
+      default: 'babel'
+    },
+    ...pathWithinParent ? [] : [{
+      name: questionNames$1.NODE_VERSION_CATEGORY,
+      message: 'What node.js version should be used?',
+      type: 'list',
+      choices: ['LTS', 'Latest'],
+      default: 'LTS'
+    }],
+    {
+      name: questionNames$1.PACKAGE_MANAGER,
+      message: 'Which package manager will be used with this project?',
+      type: 'list',
+      choices: Object.values(packageManagers$1),
+      default: packageManagers$1.NPM
+    },
+    {
+      name: questionNames$1.PROJECT_TYPE,
+      message: 'What type of JavaScript project is this?',
+      type: 'list',
+      choices: [...Object.values(projectTypes$1), 'Other'],
+      default: projectTypes$1.PACKAGE
+    },
+    ...'Private' === visibility ? [] : [{
+      name: questionNames$1.SHOULD_BE_SCOPED,
+      message: 'Should this package be scoped?',
+      type: 'confirm',
+      when: shouldBeScopedPromptShouldBePresented,
+      default: true
+    }],
+    {
+      name: questionNames$1.SCOPE,
+      message: 'What is the scope?',
+      when: scopePromptShouldBePresentedFactory(visibility),
+      validate: scope(visibility),
+      default: maybeLoggedInNpmUsername
+    },
+    ...authorQuestions({
+      name: npmConf$1.get('init.author.name'),
+      email: npmConf$1.get('init.author.email'),
+      url: npmConf$1.get('init.author.url')
+    }),
+    ...questions(({vcs, ciServices, pathWithinParent})),
+    {
+      name: questionNames$1.CONFIGURE_LINTING,
+      message: 'Will there be source code that should be linted?',
+      type: 'confirm',
+      when: lintingPromptShouldBePresented
+    },
+    {
+      name: questionNames$1.PROVIDE_EXAMPLE,
+      message: 'Should an example be provided in the README?',
+      type: 'confirm',
+      when: projectIsPackage
+    },
+    {
+      name: questionNames$1.HOST,
+      type: 'list',
+      message: 'Where will the application be hosted?',
+      when: projectIsApplication,
+      choices: [...Object.keys(hosts), 'Other']
+    }
+  ], decisions);
+
+  return {
+    tests: {unit: unitTested, integration: integrationTested},
+    projectType,
+    ci,
+    chosenHost,
+    scope: scope$1,
+    nodeVersionCategory,
+    author: {name: authorName, email: authorEmail, url: authorUrl},
+    configureLinting: false !== configureLinting,
+    provideExample,
+    packageManager,
+    dialect
+  };
+}
+
+function write$1 ({projectRoot, config}) {
+  return write$2({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+}
+
+function loadConfig ({projectRoot}) {
+  return loadConfigFile({path: projectRoot, name: '.babelrc', format: fileTypes.JSON});
+}
+
+async function addIgnore ({projectRoot, ignore}) {
+  if (ignore) {
+    const existingConfig = await loadConfig({projectRoot});
+
+    await write$1({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
+  }
+}
+
+async function scaffoldBabel ({projectRoot, preset}) {
+  if (!preset) {
+    throw new Error('No babel preset provided. Cannot configure babel transpilation');
+  }
+
+  await write$1({projectRoot, config: {presets: [preset.name]}});
+
+  return {
+    dependencies: {javascript: {development: ['@babel/register', preset.packageName]}},
+    eslint: {}
+  };
+}
+
+async function lifter$5 ({results, projectRoot}) {
+  await addIgnore({ignore: results.buildDirectory, projectRoot});
+
+  return {};
+}
+
+function predicate ({projectRoot}) {
+  return fileExists(`${projectRoot}/.babelrc.json`);
+}
+
+async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
+  const shareableTsConfigPackage = `${config.scope}/tsconfig`;
+
+  await writeConfigFile({
+    path: projectRoot,
+    name: 'tsconfig',
+    format: fileTypes.JSON,
+    config: {
+      $schema: 'https://json.schemastore.org/tsconfig',
+      extends: shareableTsConfigPackage,
+      compilerOptions: {
+        rootDir: 'src',
+        ...projectTypes$1.PACKAGE === projectType && {
+          outDir: 'lib',
+          declaration: true
+        }
+      },
+      include: ['src/**/*.ts'],
+      ...testFilenamePattern && {exclude: [testFilenamePattern]}
+    }
+  });
+
+  return {
+    eslint: {configs: ['typescript']},
+    dependencies: {javascript: {development: ['typescript', shareableTsConfigPackage]}},
+    vcsIgnore: {files: ['tsconfig.tsbuildinfo']}
+  };
+}
+
+function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
+  switch (dialect) {
+    case dialects$1.BABEL:
+      return scaffoldBabel({preset: configs.babelPreset, projectRoot});
+    case dialects$1.TYPESCRIPT:
+      return scaffoldTypescript({config: configs.typescript, projectType, projectRoot, testFilenamePattern});
+    default:
+      return {};
+  }
+}
+
+var dialects = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter$5,
+  scaffold: scaffoldDialect,
+  test: predicate
+});
+
+async function writeNpmConfig ({projectRoot, config}) {
+  await promises$1.writeFile(`${projectRoot}/.npmrc`, stringify(config));
+}
+
+function projectWillNotBeConsumed(projectType) {
+  return projectTypes$1.APPLICATION === projectType || projectTypes$1.CLI === projectType;
+}
+
+async function scaffoldNpmConfig ({projectRoot, projectType}) {
+  await writeNpmConfig({
+    projectRoot,
+    config: {'update-notifier': false, ...projectWillNotBeConsumed(projectType) && {'save-exact': true}}
+  });
+
+  return {scripts: {'lint:peer': 'npm ls >/dev/null'}};
+}
+
+function tester$4 ({projectRoot}) {
   return fileExists(`${projectRoot}/.npmrc`);
 }
 
@@ -368,148 +536,116 @@ var npmConfigPlugin = /*#__PURE__*/Object.freeze({
   lift: lifter$4,
   read: readNpmConfig,
   scaffold: scaffoldNpmConfig,
-  test: tester$3,
+  test: tester$4,
   write: writeNpmConfig
 });
 
-function buildRegistriesConfig (registries = {}) {
-  return Object.entries(registries)
-    .filter(([scope]) => 'publish' !== scope)
-    .reduce((acc, [scope, url]) => {
-      if ('registry' === scope) return {...acc, registry: url};
-
-      return {...acc, [`@${scope}:registry`]: url};
-    }, {registry: 'https://registry.npmjs.org'});
-}
-
-async function updateRegistriesInNpmConfig(registries, projectRoot) {
-  const registriesForNpmConfig = buildRegistriesConfig(registries);
+async function scaffoldNpm ({projectRoot}) {
+  const [packageContents, {stdout}] = await Promise.all([
+    promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'),
+    execa('npm', ['--version'])
+  ]);
+  const existingPackageJsonContents = JSON.parse(packageContents);
 
-  await writeNpmConfig({
+  await writePackageJson({
     projectRoot,
     config: {
-      ...(await readNpmConfig({projectRoot})),
-      ...registriesForNpmConfig
+      ...existingPackageJsonContents,
+      packageManager: `npm@${stdout}`
     }
   });
 }
 
-async function updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries) {
-  await write$1({
+function determineLockfilePathFor (packageManager) {
+  const lockfilePaths = {
+    [packageManagers$1.NPM]: 'package-lock.json',
+    [packageManagers$1.YARN]: 'yarn.lock'
+  };
+
+  return lockfilePaths[packageManager];
+}
+
+function npmIsUsed ({projectRoot, pinnedPackageManager = ''}) {
+  const [packageManager] = pinnedPackageManager.split('@');
+
+  return packageManagers$1.NPM === packageManager
+    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.NPM)}`);
+}
+
+async function scaffoldYarn ({projectRoot}) {
+  const [packageContents, {stdout}] = await Promise.all([
+    promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'),
+    execa('yarn', ['--version'])
+  ]);
+  const existingPackageJsonContents = JSON.parse(packageContents);
+
+  await writePackageJson({
     projectRoot,
     config: {
-      ...await read({projectRoot}),
-      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+      ...existingPackageJsonContents,
+      packageManager: `yarn@${stdout}`
     }
   });
 }
 
-async function lifter$3 ({projectRoot, packageManager, configs: {registries}}) {
-  await updateRegistriesInNpmConfig(registries, projectRoot);
+function yarnIsUsed ({projectRoot, pinnedPackageManager = ''}) {
+  const [packageManager] = pinnedPackageManager.split('@');
 
-  if (!(await lockfileLintIsAlreadyConfigured({projectRoot}))) {
-    return scaffoldLockfileLint({projectRoot, packageManager, registries});
-  }
+  return packageManagers$1.YARN === packageManager
+    || fileExists(`${projectRoot}/${determineLockfilePathFor(packageManagers$1.YARN)}`);
+}
 
-  await updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries);
+async function jsPackageManagerIsUsed ({projectRoot}) {
+  const [npmFound, yarnFound] = await Promise.all([
+    npmIsUsed({projectRoot}),
+    yarnIsUsed({projectRoot})
+  ]);
 
-  return {};
+  return npmFound || yarnFound;
 }
 
-var registriesPlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lifter$3,
-  test: tester$4
-});
+async function liftCorepack () {
+  await execa('corepack', ['use', 'npm@latest']);
+}
 
-async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
-  await write$2({
-    format: fileTypes.JSON,
-    path: projectRoot,
-    name: 'remark',
-    config: {
-      settings: {
-        listItemIndent: 'one',
-        emphasis: '_',
-        strong: '_',
-        bullet: '*',
-        incrementListMarker: false
-      },
-      plugins: [
-        config,
-        ['remark-toc', {tight: true}],
-        ...projectTypes$1.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
-        ...!vcs ? [['validate-links', {repository: false}]] : []
-      ]
-    }
-  });
+async function lifter$3 () {
+  await liftCorepack();
 
-  return deepmerge(
-    {
-      dependencies: {javascript: {development: [config, 'remark-cli', 'remark-toc']}},
-      scripts: {
-        'lint:md': 'remark . --frail',
-        'generate:md': 'remark . --output'
-      }
-    },
-    {...projectTypes$1.PACKAGE === projectType && {dependencies: {javascript: {development: ['remark-usage']}}}}
-  );
+  return {};
 }
 
-async function scaffoldCodeStyle ({
-  projectRoot,
-  projectType,
-  configs,
-  vcs,
-  configureLinting
-}) {
-  return deepmerge.all(await Promise.all([
-    configs.eslint
-      && configureLinting
-      && scaffold$1({projectRoot, config: configs.eslint}),
-    scaffoldRemark({
-      projectRoot,
-      projectType,
-      vcs,
-      config: configs.remark || '@form8ion/remark-lint-preset'
-    }),
-    scaffold$2({projectRoot, config: configs.prettier})
-  ].filter(Boolean)));
-}
+const scaffolders = {
+  npm: scaffoldNpm,
+  yarn: scaffoldYarn
+};
 
-function lifter$2 (options) {
-  return applyEnhancers({options, enhancers: [eslintPlugin]});
+function scaffoldPackageManager ({projectRoot, packageManager}) {
+  return scaffolders[packageManager]({projectRoot});
 }
 
-function tester$2 (options) {
-  return test$1(options);
-}
+async function resolvePackageManager ({projectRoot, packageManager}) {
+  if (packageManager) return packageManager;
 
-var codeStylePlugin = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lifter$2,
-  scaffold: scaffoldCodeStyle,
-  test: tester$2
-});
+  const {packageManager: pinnedPackageManager} = JSON.parse(await promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'));
 
-async function test({projectRoot}) {
-  const {engines} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+  if (await npmIsUsed({projectRoot, pinnedPackageManager})) {
+    return packageManagers$1.NPM;
+  }
 
-  return !!engines?.node;
-}
+  if (await yarnIsUsed({projectRoot, pinnedPackageManager})) {
+    return packageManagers$1.YARN;
+  }
 
-async function lift$1({packageDetails: {name}}) {
-  return {
-    dependencies: {javascript: {development: ['ls-engines']}},
-    scripts: {'lint:engines': 'ls-engines'},
-    badges: {consumer: {node: {img: `https://img.shields.io/node/v/${name}?logo=node.js`, text: 'node'}}}
-  };
+  throw new Error('Package-manager could not be determined');
 }
 
-var enginesEnhancer = /*#__PURE__*/Object.freeze({
+var packageManagers = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  lift: lift$1,
-  test: test
+  defineLockfilePath: determineLockfilePathFor,
+  determineCurrent: resolvePackageManager,
+  lift: lifter$3,
+  scaffold: scaffoldPackageManager,
+  test: jsPackageManagerIsUsed
 });
 
 function buildDocumentationCommand (packageManager) {
@@ -522,1153 +658,772 @@ function buildDocumentationCommand (packageManager) {
   );
 }
 
-function getInstallationCommand(packageManager) {
-  if (packageManagers$1.NPM === packageManager) return 'npm install';
-  if (packageManagers$1.YARN === packageManager) return 'yarn add';
-
-  throw new Error(
-    `The ${packageManager} package manager is currently not supported. `
-    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
-  );
-}
-
-function scaffoldPackageDocumentation ({scope, packageName, packageManager, visibility, provideExample}) {
+function scaffoldDocumentation ({projectTypeResults, packageManager}) {
   return {
-    usage: `### Installation
-${'Private' === visibility ? `
-:warning: this is a private package, so you will need to use an npm token with
-access to private packages under \`@${scope}\`
-` : ''
-}
+    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`,
+    ...projectTypeResults.documentation,
+    contributing: `### Dependencies
+
 \`\`\`sh
-$ ${getInstallationCommand(packageManager)} ${packageName}
-\`\`\`${provideExample
-    ? `
+$ nvm install
+$ ${packageManager} install
+\`\`\`
 
-### Example
+### Verification
 
-run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example`
-    : ''
-}`
+\`\`\`sh
+$ ${packageManager} test
+\`\`\``
   };
 }
 
-function determinePackageAccessLevelFromProjectVisibility ({projectVisibility}) {
-  return 'Public' === projectVisibility ? 'public' : 'restricted';
-}
+async function determineLatestVersionOf(nodeVersionCategory) {
+  info('Determining version of node', {level: 'secondary'});
 
-function defineBadges (packageName, accessLevel) {
-  return {
-    consumer: {
-      ...'public' === accessLevel && {
-        npm: {
-          img: `https://img.shields.io/npm/v/${packageName}?logo=npm`,
-          text: 'npm',
-          link: `https://www.npmjs.com/package/${packageName}`
-        }
-      }
-    },
-    status: {}
-  };
+  const {stdout: nvmLsOutput} = await execa(
+    `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
+    {shell: true}
+  );
+
+  const lsLines = nvmLsOutput.split('\n');
+  const lsLine = lsLines[lsLines.length - 2];
+
+  return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
 }
 
-function enhanceSlsa ({provenance}) {
-  if (provenance) {
-    return {
-      badges: {
-        status: {
-          slsa: {
-            img: 'https://slsa.dev/images/gh-badge-level2.svg',
-            url: 'https://slsa.dev',
-            text: 'SLSA Level 2'
-          }
-        }
-      }
-    };
-  }
+function install$1(nodeVersionCategory) {
+  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
 
-  return {};
+  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
+  subprocess.stdout.pipe(process.stdout);
+  return subprocess;
 }
 
-async function liftProvenance ({projectRoot, packageDetails}) {
-  const {publishConfig: {access}} = packageDetails;
+async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
+  if (!nodeVersionCategory) return undefined;
 
-  if ('public' === access) {
-    await mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
+  const lowerCaseCategory = nodeVersionCategory.toLowerCase();
+  info(`Configuring ${lowerCaseCategory} version of node`);
 
-    return enhanceSlsa({provenance: true});
-  }
+  const version = await determineLatestVersionOf(nodeVersionCategory);
 
-  return {};
-}
+  await promises$1.writeFile(`${projectRoot}/.nvmrc`, version);
 
-async function liftPublishable ({projectRoot, packageDetails}) {
-  const {name: packageName, publishConfig: {access: packageAccessLevel}} = packageDetails;
-  const homepage = `https://npm.im/${packageName}`;
+  await install$1(nodeVersionCategory);
 
-  await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+  return version;
+}
 
-  return deepmerge(
-    await liftProvenance({packageDetails, projectRoot}),
-    {
-      homepage,
-      dependencies: {javascript: {development: ['publint']}},
-      scripts: {'lint:publish': 'publint --strict'},
-      badges: defineBadges(packageName, packageAccessLevel)
-    }
-  );
+function nvmIsUsed ({projectRoot}) {
+  return fileExists(`${projectRoot}/.nvmrc`);
 }
 
-async function scaffoldPublishable ({packageName, packageAccessLevel}) {
+function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
   return {
-    badges: await defineBadges(packageName, packageAccessLevel)
+    files: vcsIgnoreLists.files || [],
+    directories: ['/node_modules/', ...vcsIgnoreLists.directories || []]
   };
 }
 
-async function chooseBundler ({bundlers, decisions}) {
-  if (!Object.keys(bundlers).length) return 'Other';
-
-  const answers = await prompt$1([{
-    name: questionNames$1.PACKAGE_BUNDLER,
-    type: 'list',
-    message: 'Which bundler should be used?',
-    choices: [...Object.keys(bundlers), 'Other']
-  }], decisions);
+function buildPackageName (projectName, scope) {
+  const name = `${scope ? `@${scope}/` : ''}${projectName}`;
 
-  return answers[questionNames$1.PACKAGE_BUNDLER];
-}
+  const {validForNewPackages, errors} = validatePackageName(name);
 
-async function scaffoldBundler ({projectRoot, projectType, bundlers, dialect, decisions}) {
-  const chosenBundler = await chooseBundler({bundlers, decisions});
+  if (validForNewPackages) return name;
+  if (1 === errors.length && errors.includes('name cannot start with a period')) return projectName.slice(1);
 
-  return scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
+  throw new Error(`The package name ${name} is invalid:${EOL}\t* ${errors.join(`${EOL}\t* `)}`);
 }
 
-function determinePathToTemplateFile (fileName) {
-  const [, __dirname] = filedirname();
-
-  return resolve(__dirname, '..', 'templates', fileName);
-}
-
-const defaultBuildDirectory$2 = 'lib';
-
-async function createExample(projectRoot, projectName, dialect) {
-  return promises.writeFile(
-    `${projectRoot}/example.js`,
-    mustache.render(
-      await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'),
-      {projectName: camelcase(projectName), esm: dialect === dialects$1.ESM}
-    )
-  );
-}
-
-async function buildDetailsForCommonJsProject({projectRoot, projectName, provideExample}) {
-  await Promise.all([
-    touch(`${projectRoot}/index.js`),
-    provideExample
-      ? promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)
-      : Promise.resolve()
-  ]);
-
-  return {};
-}
-
-async function buildDetails ({
-  projectRoot,
-  projectName,
-  visibility,
+function buildPackageDetails ({
   packageName,
-  packageBundlers,
   dialect,
-  provideExample,
-  decisions
+  license,
+  author,
+  description
 }) {
-  if (dialects$1.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName, provideExample});
-
-  const pathToCreatedSrcDirectory = await mkdir(`${projectRoot}/src`);
-  const [bundlerResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.PACKAGE}),
-    provideExample ? await createExample(projectRoot, projectName, dialect) : Promise.resolve,
-    touch(`${pathToCreatedSrcDirectory}/index.js`)
-  ]);
-
-  return deepmerge(
-    bundlerResults,
-    {
-      dependencies: {javascript: {development: ['rimraf']}},
-      scripts: {
-        clean: `rimraf ./${defaultBuildDirectory$2}`,
-        prebuild: 'run-s clean',
-        build: 'npm-run-all --print-label --parallel build:*',
-        prepack: 'run-s build',
-        ...provideExample && {'pregenerate:md': 'run-s build'}
-      },
-      vcsIgnore: {directories: [`/${defaultBuildDirectory$2}/`]},
-      buildDirectory: defaultBuildDirectory$2,
-      badges: {
-        consumer: {
-          ...'Public' === visibility && {
-            runkit: {
-              img: `https://badge.runkitcdn.com/${packageName}.svg`,
-              text: `Try ${packageName} on RunKit`,
-              link: `https://npm.runkit.com/${packageName}`
-            }
-          }
-        }
-      }
-    }
-  );
+  return {
+    name: packageName,
+    description,
+    license,
+    type: dialects$1.ESM === dialect ? 'module' : 'commonjs',
+    author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
+    scripts: {}
+  };
 }
 
-async function scaffoldPackageType ({
+async function scaffoldPackage ({
   projectRoot,
   projectName,
-  packageName,
-  packageManager,
-  visibility,
   scope,
-  packageBundlers,
-  decisions,
   dialect,
-  provideExample,
-  publishRegistry
+  license,
+  author,
+  description
 }) {
-  info('Scaffolding Package Details');
+  info('Configuring package.json');
 
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
-  const [detailsForBuild, publishableResults] = await Promise.all([
-    buildDetails({
-      projectRoot,
-      projectName,
-      packageBundlers,
-      visibility,
+  const packageName = buildPackageName(projectName, scope);
+
+  await writePackageJson({
+    projectRoot,
+    config: await buildPackageDetails({
       packageName,
       dialect,
-      provideExample,
-      decisions
-    }),
-    scaffoldPublishable({packageName, packageAccessLevel}),
-    mergeIntoExistingPackageJson({
-      projectRoot,
-      config: {
-        files: ['example.js', ...dialects$1.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
-        publishConfig: {
-          access: packageAccessLevel,
-          ...publishRegistry && {registry: publishRegistry}
-        },
-        sideEffects: false,
-        ...'Public' === visibility && {runkitExampleFilename: './example.js'},
-        ...dialects$1.BABEL === dialect && {
-          main: './lib/index.js',
-          module: './lib/index.mjs',
-          exports: {
-            module: './lib/index.mjs',
-            require: './lib/index.js',
-            import: './lib/index.mjs'
-          }
-        },
-        ...dialects$1.ESM === dialect && {
-          main: './lib/index.js',
-          exports: './lib/index.js'
-        },
-        ...dialects$1.TYPESCRIPT === dialect && {
-          main: './lib/index.js',
-          module: './lib/index.mjs',
-          types: './lib/index.d.ts',
-          exports: {
-            types: './lib/index.d.ts',
-            require: './lib/index.js',
-            import: './lib/index.mjs'
-          }
-        }
-      }
+      license,
+      author,
+      description
     })
-  ]);
+  });
 
-  return deepmerge.all([
-    publishableResults,
-    {
-      documentation: scaffoldPackageDocumentation({packageName, visibility, scope, packageManager, provideExample}),
-      nextSteps: [
-        {summary: 'Add the appropriate `save` flag to the installation instructions in the README'},
-        {summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'},
-        {summary: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'}
-      ]
-    },
-    detailsForBuild
-  ]);
+  return {packageName};
 }
 
-function liftPackage$1 ({projectRoot, packageDetails}) {
-  return liftPublishable({projectRoot, packageDetails});
+function sortPackageProperties (packageContents) {
+  return sortProperties(
+    packageContents,
+    [
+      'name',
+      'description',
+      'license',
+      'version',
+      'private',
+      'type',
+      'engines',
+      'author',
+      'contributors',
+      'repository',
+      'bugs',
+      'homepage',
+      'funding',
+      'keywords',
+      'runkitExampleFilename',
+      'exports',
+      'bin',
+      'main',
+      'module',
+      'types',
+      'sideEffects',
+      'scripts',
+      'files',
+      'publishConfig',
+      'packageManager',
+      'config',
+      'dependencies',
+      'devDependencies',
+      'peerDependencies'
+    ]
+  );
 }
 
-async function isPackage ({packageDetails: {exports, publishConfig, bin}}) {
-  return !!exports || (!!publishConfig && !bin);
+function defineVcsHostDetails (vcs, pathWithinParent) {
+  return vcs && 'github' === vcs.host && {
+    repository: pathWithinParent
+      ? {
+        type: 'git',
+        url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
+        directory: pathWithinParent
+      }
+      : `${vcs.owner}/${vcs.name}`,
+    bugs: `https://github.com/${vcs.owner}/${vcs.name}/issues`
+  };
 }
 
-const defaultBuildDirectory$1 = 'public';
-
-async function scaffoldApplicationType ({projectRoot}) {
-  info('Scaffolding Application Details');
-
-  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
-
-  const buildDirectory = defaultBuildDirectory$1;
+const details = {
+  [packageManagers$1.NPM]: {
+    installationCommand: 'install',
+    installationFlags: {
+      [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
+      [PROD_DEPENDENCY_TYPE]: `save-${PROD_DEPENDENCY_TYPE}`,
+      exact: 'save-exact'
+    }
+  },
+  [packageManagers$1.YARN]: {
+    installationCommand: 'add',
+    installationFlags: {
+      [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
+      [PROD_DEPENDENCY_TYPE]: PROD_DEPENDENCY_TYPE,
+      exact: 'exact'
+    }
+  }
+};
 
-  return {
-    scripts: {
-      clean: `rimraf ./${buildDirectory}`,
-      start: `node ./${buildDirectory}/index.js`,
-      prebuild: 'run-s clean'
-    },
-    dependencies: {javascript: {development: ['rimraf']}},
-    vcsIgnore: {files: ['.env'], directories: [`/${buildDirectory}/`]},
-    buildDirectory,
-    nextSteps: []
-  };
+function getInstallationCommandFor(manager) {
+  return details[manager].installationCommand;
 }
 
-function isApplication ({packageDetails}) {
-  return !!packageDetails.private;
+function getDependencyTypeFlag(manager, type) {
+  return details[manager].installationFlags[type];
 }
 
-async function scaffoldMonorepoType ({projectRoot}) {
-  info('Scaffolding Monorepo Details');
+function getExactFlag(manager) {
+  return details[manager].installationFlags.exact;
+}
 
-  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
+async function install (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
+  if (dependencies.length) {
+    info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
 
-  return {
-    nextSteps: [{
-      summary: 'Add packages to your new monorepo',
-      description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
-        + ' to scaffold new packages into your new monorepo'
-    }]
-  };
+    await execa(
+      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${
+        getInstallationCommandFor(packageManager)
+      } ${[...new Set(dependencies)].join(' ')} --${getDependencyTypeFlag(packageManager, dependenciesType)}${
+        DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
+      }`,
+      {shell: true, cwd: projectRoot}
+    );
+  } else warn(`No ${dependenciesType} dependencies to install`);
 }
 
-const defaultBuildDirectory = 'bin';
+async function processDependencies ({dependencies = {}, devDependencies, projectRoot, packageManager}) {
+  info('Processing dependencies');
 
-async function scaffoldCliType ({
-  packageName,
-  visibility,
-  projectRoot,
-  dialect,
-  publishRegistry,
-  decisions,
-  packageBundlers
-}) {
-  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
-  const [bundlerResults, publishableResults] = await Promise.all([
-    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.CLI}),
-    scaffoldPublishable({packageName, packageAccessLevel}),
-    mergeIntoExistingPackageJson({
-      projectRoot,
-      config: {
-        bin: {},
-        files: [`${defaultBuildDirectory}/`],
-        publishConfig: {
-          access: packageAccessLevel,
-          ...publishRegistry && {registry: publishRegistry}
-        }
-      }
-    })
-  ]);
+  if (Array.isArray(devDependencies)) {
+    throw new Error(
+      `devDependencies provided as: ${devDependencies}. Instead, provide under dependencies.javascript.development`
+    );
+  }
 
-  return deepmerge.all([
-    publishableResults,
-    bundlerResults,
-    {
-      scripts: {
-        clean: `rimraf ./${defaultBuildDirectory}`,
-        prebuild: 'run-s clean',
-        build: 'npm-run-all --print-label --parallel build:*',
-        prepack: 'run-s build'
-      },
-      dependencies: {javascript: {production: ['update-notifier'], development: ['rimraf']}},
-      vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
-      buildDirectory: defaultBuildDirectory,
-      nextSteps: [{summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'}]
-    }
-  ]);
-}
+  if (Array.isArray(dependencies)) {
+    throw new Error(`Expected dependencies to be an object. Instead received: ${dependencies}`);
+  }
 
-async function isCli ({packageDetails: {bin}}) {
-  return !!bin;
-}
+  const {javascript: {production = [], development = []} = {}} = dependencies;
 
-function liftCli ({projectRoot, packageDetails}) {
-  return liftPublishable({projectRoot, packageDetails});
+  try {
+    await install(production, PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
+    await install(development, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
+  } catch (e) {
+    error('Failed to update dependencies');
+    error(e, {level: 'secondary'});
+  }
 }
 
-async function scaffoldProjectType ({
-  projectType,
-  projectRoot,
-  projectName,
-  packageName,
-  packageManager,
-  visibility,
-  packageBundlers,
-  scope,
-  decisions,
-  dialect,
-  provideExample,
-  publishRegistry
-}) {
-  switch (projectType) {
-    case projectTypes$1.PACKAGE:
-      return scaffoldPackageType({
-        projectRoot,
-        projectName,
-        packageName,
-        packageManager,
-        visibility,
-        scope,
-        packageBundlers,
-        decisions,
-        dialect,
-        provideExample,
-        publishRegistry
-      });
-    case projectTypes$1.APPLICATION:
-      return scaffoldApplicationType({projectRoot});
-    case projectTypes$1.CLI:
-      return scaffoldCliType({
-        packageName,
-        visibility,
-        projectRoot,
-        dialect,
-        publishRegistry,
-        decisions,
-        packageBundlers
-      });
-    case projectTypes$1.MONOREPO:
-      return scaffoldMonorepoType({projectRoot});
-    case 'Other':
-      return {};
-    default:
-      throw new Error(`The project-type of ${projectType} is invalid`);
-  }
+function projectWillBeTested(scripts) {
+  return Object.keys(scripts).find(scriptName => scriptName.startsWith('test:'));
 }
 
-async function tester$1 ({projectRoot, packageDetails}) {
-  return await isPackage({projectRoot, packageDetails})
-    || await isCli({projectRoot, packageDetails})
-    || isApplication({projectRoot, packageDetails});
+function projectShouldBeBuiltForVerification(scripts) {
+  return 'run-s build' === scripts['pregenerate:md'];
 }
 
-function vcsRepositoryHostedOnGithub(vcs) {
-  return vcs && 'github' === vcs.host;
+function updateTestScript (scripts) {
+  return {
+    ...scripts,
+    test: `npm-run-all --print-label${
+      projectShouldBeBuiltForVerification(scripts) ? ' build' : ''
+    } --parallel lint:*${
+      projectWillBeTested(scripts) ? ' --parallel test:*' : ''
+    }`
+  };
 }
 
-async function lifter$1 ({projectRoot, packageDetails, vcs}) {
-  if (await isPackage({projectRoot, packageDetails})) return liftPackage$1({projectRoot, packageDetails});
-  if (await isCli({projectRoot, packageDetails})) return liftCli({projectRoot, packageDetails});
+function liftScripts ({existingScripts, scripts}) {
+  return {
+    scripts: updateTestScript({...existingScripts, ...scripts}),
+    dependencies: {javascript: {development: ['npm-run-all2']}}
+  };
+}
 
-  let homepage;
+async function liftPackage$1 ({
+  projectRoot,
+  scripts,
+  tags,
+  dependencies,
+  devDependencies,
+  packageManager,
+  vcs,
+  pathWithinParent
+}) {
+  info('Updating `package.json`', {level: 'secondary'});
 
-  if (vcsRepositoryHostedOnGithub(vcs)) {
-    homepage = `https://github.com/${vcs.owner}/${vcs.name}#readme`;
+  const existingPackageJsonContents = JSON.parse(await promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'));
+  const {scripts: liftedScripts, dependencies: scriptDependencies} = liftScripts({
+    existingScripts: existingPackageJsonContents.scripts,
+    scripts
+  });
 
-    await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
-  }
+  await writePackageJson({
+    projectRoot,
+    config: sortPackageProperties({
+      ...existingPackageJsonContents,
+      ...defineVcsHostDetails(vcs, pathWithinParent),
+      scripts: liftedScripts,
+      ...tags && {
+        keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
+      }
+    })
+  });
 
-  return {homepage};
+  await processDependencies({
+    dependencies: deepmerge(dependencies, scriptDependencies),
+    devDependencies,
+    projectRoot,
+    packageManager
+  });
 }
 
-var projectTypes = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lifter$1,
-  scaffold: scaffoldProjectType,
-  test: tester$1
-});
+function getInstallationCommand(packageManager) {
+  if (packageManagers$1.NPM === packageManager) return 'npm install';
+  if (packageManagers$1.YARN === packageManager) return 'yarn add';
 
-function write ({projectRoot, config}) {
-  return write$2({path: projectRoot, name: 'babel', format: fileTypes.JSON, config});
+  throw new Error(
+    `The ${packageManager} package manager is currently not supported. `
+    + `Only ${Object.values(packageManagers$1).join(' and ')} are currently supported.`
+  );
 }
 
-function loadConfig ({projectRoot}) {
-  return loadConfigFile({path: projectRoot, name: '.babelrc', format: fileTypes.JSON});
+function scaffoldPackageDocumentation ({scope, packageName, packageManager, visibility, provideExample}) {
+  return {
+    usage: `### Installation
+${'Private' === visibility ? `
+:warning: this is a private package, so you will need to use an npm token with
+access to private packages under \`@${scope}\`
+` : ''
 }
+\`\`\`sh
+$ ${getInstallationCommand(packageManager)} ${packageName}
+\`\`\`${provideExample
+    ? `
 
-async function addIgnore ({projectRoot, ignore}) {
-  if (ignore) {
-    const existingConfig = await loadConfig({projectRoot});
+### Example
 
-    await write({projectRoot, config: {...existingConfig, ignore: [`./${ignore}/`]}});
-  }
+run \`${buildDocumentationCommand(packageManager)}\` to inject the usage example`
+    : ''
+}`
+  };
 }
 
-async function scaffoldBabel ({projectRoot, preset}) {
-  if (!preset) {
-    throw new Error('No babel preset provided. Cannot configure babel transpilation');
-  }
-
-  await write({projectRoot, config: {presets: [preset.name]}});
+function determinePackageAccessLevelFromProjectVisibility ({projectVisibility}) {
+  return 'Public' === projectVisibility ? 'public' : 'restricted';
+}
 
+function defineBadges (packageName, accessLevel) {
   return {
-    dependencies: {javascript: {development: ['@babel/register', preset.packageName]}},
-    eslint: {}
+    consumer: {
+      ...'public' === accessLevel && {
+        npm: {
+          img: `https://img.shields.io/npm/v/${packageName}?logo=npm`,
+          text: 'npm',
+          link: `https://www.npmjs.com/package/${packageName}`
+        }
+      }
+    },
+    status: {}
   };
 }
 
-async function lifter ({results, projectRoot}) {
-  await addIgnore({ignore: results.buildDirectory, projectRoot});
+function enhanceSlsa ({provenance}) {
+  if (provenance) {
+    return {
+      badges: {
+        status: {
+          slsa: {
+            img: 'https://slsa.dev/images/gh-badge-level2.svg',
+            url: 'https://slsa.dev',
+            text: 'SLSA Level 2'
+          }
+        }
+      }
+    };
+  }
 
   return {};
 }
 
-function predicate ({projectRoot}) {
-  return fileExists(`${projectRoot}/.babelrc.json`);
+async function liftProvenance ({projectRoot, packageDetails}) {
+  const {publishConfig: {access}} = packageDetails;
+
+  if ('public' === access) {
+    await mergeIntoExistingPackageJson({projectRoot, config: {publishConfig: {provenance: true}}});
+
+    return enhanceSlsa({provenance: true});
+  }
+
+  return {};
 }
 
-async function scaffoldTypescript ({config, projectType, projectRoot, testFilenamePattern}) {
-  const shareableTsConfigPackage = `${config.scope}/tsconfig`;
+async function liftPublishable ({projectRoot, packageDetails}) {
+  const {name: packageName, publishConfig: {access: packageAccessLevel}} = packageDetails;
+  const homepage = `https://npm.im/${packageName}`;
 
-  await writeConfigFile({
-    path: projectRoot,
-    name: 'tsconfig',
-    format: fileTypes.JSON,
-    config: {
-      $schema: 'https://json.schemastore.org/tsconfig',
-      extends: shareableTsConfigPackage,
-      compilerOptions: {
-        rootDir: 'src',
-        ...projectTypes$1.PACKAGE === projectType && {
-          outDir: 'lib',
-          declaration: true
-        }
-      },
-      include: ['src/**/*.ts'],
-      ...testFilenamePattern && {exclude: [testFilenamePattern]}
+  await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+
+  return deepmerge(
+    await liftProvenance({packageDetails, projectRoot}),
+    {
+      homepage,
+      dependencies: {javascript: {development: ['publint']}},
+      scripts: {'lint:publish': 'publint --strict'},
+      badges: defineBadges(packageName, packageAccessLevel)
     }
-  });
+  );
+}
 
+async function scaffoldPublishable ({packageName, packageAccessLevel}) {
   return {
-    eslint: {configs: ['typescript']},
-    dependencies: {javascript: {development: ['typescript', shareableTsConfigPackage]}},
-    vcsIgnore: {files: ['tsconfig.tsbuildinfo']}
+    badges: await defineBadges(packageName, packageAccessLevel)
   };
 }
 
-function scaffoldDialect ({dialect, projectType, projectRoot, configs, testFilenamePattern}) {
-  switch (dialect) {
-    case dialects$1.BABEL:
-      return scaffoldBabel({preset: configs.babelPreset, projectRoot});
-    case dialects$1.TYPESCRIPT:
-      return scaffoldTypescript({config: configs.typescript, projectType, projectRoot, testFilenamePattern});
-    default:
-      return {};
-  }
+async function chooseBundler ({bundlers, decisions}) {
+  if (!Object.keys(bundlers).length) return 'Other';
+
+  const answers = await prompt$1([{
+    name: questionNames$1.PACKAGE_BUNDLER,
+    type: 'list',
+    message: 'Which bundler should be used?',
+    choices: [...Object.keys(bundlers), 'Other']
+  }], decisions);
+
+  return answers[questionNames$1.PACKAGE_BUNDLER];
 }
 
-var dialects = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  lift: lifter,
-  scaffold: scaffoldDialect,
-  test: predicate
-});
+async function scaffoldBundler ({projectRoot, projectType, bundlers, dialect, decisions}) {
+  const chosenBundler = await chooseBundler({bundlers, decisions});
 
-function buildPackageName (projectName, scope) {
-  const name = `${scope ? `@${scope}/` : ''}${projectName}`;
+  return scaffoldChoice(bundlers, chosenBundler, {projectRoot, projectType, dialect});
+}
 
-  const {validForNewPackages, errors} = validatePackageName(name);
+function determinePathToTemplateFile (fileName) {
+  const [, __dirname] = filedirname();
 
-  if (validForNewPackages) return name;
-  if (1 === errors.length && errors.includes('name cannot start with a period')) return projectName.slice(1);
+  return resolve(__dirname, '..', 'templates', fileName);
+}
 
-  throw new Error(`The package name ${name} is invalid:${EOL}\t* ${errors.join(`${EOL}\t* `)}`);
+const defaultBuildDirectory$2 = 'lib';
+
+async function createExample(projectRoot, projectName, dialect) {
+  return promises.writeFile(
+    `${projectRoot}/example.js`,
+    mustache.render(
+      await promises.readFile(determinePathToTemplateFile('example.mustache'), 'utf8'),
+      {projectName: camelcase(projectName), esm: dialect === dialects$1.ESM}
+    )
+  );
 }
 
-function buildPackageDetails ({
+async function buildDetailsForCommonJsProject({projectRoot, projectName, provideExample}) {
+  await Promise.all([
+    touch(`${projectRoot}/index.js`),
+    provideExample
+      ? promises.writeFile(`${projectRoot}/example.js`, `const ${camelcase(projectName)} = require('.');\n`)
+      : Promise.resolve()
+  ]);
+
+  return {};
+}
+
+async function buildDetails ({
+  projectRoot,
+  projectName,
+  visibility,
   packageName,
+  packageBundlers,
   dialect,
-  license,
-  author,
-  description
+  provideExample,
+  decisions
 }) {
-  return {
-    name: packageName,
-    description,
-    license,
-    type: dialects$1.ESM === dialect ? 'module' : 'commonjs',
-    author: `${author.name}${author.email ? ` <${author.email}>` : ''}${author.url ? ` (${author.url})` : ''}`,
-    scripts: {}
-  };
+  if (dialects$1.COMMON_JS === dialect) return buildDetailsForCommonJsProject({projectRoot, projectName, provideExample});
+
+  const pathToCreatedSrcDirectory = await mkdir(`${projectRoot}/src`);
+  const [bundlerResults] = await Promise.all([
+    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.PACKAGE}),
+    provideExample ? await createExample(projectRoot, projectName, dialect) : Promise.resolve,
+    touch(`${pathToCreatedSrcDirectory}/index.js`)
+  ]);
+
+  return deepmerge(
+    bundlerResults,
+    {
+      dependencies: {javascript: {development: ['rimraf']}},
+      scripts: {
+        clean: `rimraf ./${defaultBuildDirectory$2}`,
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build',
+        ...provideExample && {'pregenerate:md': 'run-s build'}
+      },
+      vcsIgnore: {directories: [`/${defaultBuildDirectory$2}/`]},
+      buildDirectory: defaultBuildDirectory$2,
+      badges: {
+        consumer: {
+          ...'Public' === visibility && {
+            runkit: {
+              img: `https://badge.runkitcdn.com/${packageName}.svg`,
+              text: `Try ${packageName} on RunKit`,
+              link: `https://npm.runkit.com/${packageName}`
+            }
+          }
+        }
+      }
+    }
+  );
 }
 
-async function scaffoldPackage ({
+async function scaffoldPackageType ({
   projectRoot,
   projectName,
+  packageName,
+  packageManager,
+  visibility,
   scope,
+  packageBundlers,
+  decisions,
   dialect,
-  license,
-  author,
-  description
+  provideExample,
+  publishRegistry
 }) {
-  info('Configuring package.json');
-
-  const packageName = buildPackageName(projectName, scope);
+  info('Scaffolding Package Details');
 
-  await writePackageJson({
-    projectRoot,
-    config: await buildPackageDetails({
+  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
+  const [detailsForBuild, publishableResults] = await Promise.all([
+    buildDetails({
+      projectRoot,
+      projectName,
+      packageBundlers,
+      visibility,
       packageName,
       dialect,
-      license,
-      author,
-      description
+      provideExample,
+      decisions
+    }),
+    scaffoldPublishable({packageName, packageAccessLevel}),
+    mergeIntoExistingPackageJson({
+      projectRoot,
+      config: {
+        files: ['example.js', ...dialects$1.COMMON_JS === dialect ? ['index.js'] : ['lib/']],
+        publishConfig: {
+          access: packageAccessLevel,
+          ...publishRegistry && {registry: publishRegistry}
+        },
+        sideEffects: false,
+        ...'Public' === visibility && {runkitExampleFilename: './example.js'},
+        ...dialects$1.BABEL === dialect && {
+          main: './lib/index.js',
+          module: './lib/index.mjs',
+          exports: {
+            module: './lib/index.mjs',
+            require: './lib/index.js',
+            import: './lib/index.mjs'
+          }
+        },
+        ...dialects$1.ESM === dialect && {
+          main: './lib/index.js',
+          exports: './lib/index.js'
+        },
+        ...dialects$1.TYPESCRIPT === dialect && {
+          main: './lib/index.js',
+          module: './lib/index.mjs',
+          types: './lib/index.d.ts',
+          exports: {
+            types: './lib/index.d.ts',
+            require: './lib/index.js',
+            import: './lib/index.mjs'
+          }
+        }
+      }
     })
-  });
-
-  return {packageName};
-}
+  ]);
 
-function sortPackageProperties (packageContents) {
-  return sortProperties(
-    packageContents,
-    [
-      'name',
-      'description',
-      'license',
-      'version',
-      'private',
-      'type',
-      'engines',
-      'author',
-      'contributors',
-      'repository',
-      'bugs',
-      'homepage',
-      'funding',
-      'keywords',
-      'runkitExampleFilename',
-      'exports',
-      'bin',
-      'main',
-      'module',
-      'types',
-      'sideEffects',
-      'scripts',
-      'files',
-      'publishConfig',
-      'packageManager',
-      'config',
-      'dependencies',
-      'devDependencies',
-      'peerDependencies'
-    ]
-  );
-}
-
-function defineVcsHostDetails (vcs, pathWithinParent) {
-  return vcs && 'github' === vcs.host && {
-    repository: pathWithinParent
-      ? {
-        type: 'git',
-        url: `https://github.com/${vcs.owner}/${vcs.name}.git`,
-        directory: pathWithinParent
-      }
-      : `${vcs.owner}/${vcs.name}`,
-    bugs: `https://github.com/${vcs.owner}/${vcs.name}/issues`
-  };
-}
-
-const details = {
-  [packageManagers$1.NPM]: {
-    installationCommand: 'install',
-    installationFlags: {
-      [DEV_DEPENDENCY_TYPE]: `save-${DEV_DEPENDENCY_TYPE}`,
-      [PROD_DEPENDENCY_TYPE]: `save-${PROD_DEPENDENCY_TYPE}`,
-      exact: 'save-exact'
-    }
-  },
-  [packageManagers$1.YARN]: {
-    installationCommand: 'add',
-    installationFlags: {
-      [DEV_DEPENDENCY_TYPE]: DEV_DEPENDENCY_TYPE,
-      [PROD_DEPENDENCY_TYPE]: PROD_DEPENDENCY_TYPE,
-      exact: 'exact'
-    }
-  }
-};
-
-function getInstallationCommandFor(manager) {
-  return details[manager].installationCommand;
-}
-
-function getDependencyTypeFlag(manager, type) {
-  return details[manager].installationFlags[type];
+  return deepmerge.all([
+    publishableResults,
+    {
+      documentation: scaffoldPackageDocumentation({packageName, visibility, scope, packageManager, provideExample}),
+      nextSteps: [
+        {summary: 'Add the appropriate `save` flag to the installation instructions in the README'},
+        {summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'},
+        {summary: 'Publish pre-release versions to npm until package is stable enough to publish v1.0.0'}
+      ]
+    },
+    detailsForBuild
+  ]);
 }
 
-function getExactFlag(manager) {
-  return details[manager].installationFlags.exact;
+function liftPackage ({projectRoot, packageDetails}) {
+  return liftPublishable({projectRoot, packageDetails});
 }
 
-async function install$1 (dependencies, dependenciesType, projectRoot, packageManager = packageManagers$1.NPM) {
-  if (dependencies.length) {
-    info(`Installing ${dependenciesType} dependencies`, {level: 'secondary'});
-
-    await execa(
-      `. ~/.nvm/nvm.sh && nvm use && ${packageManager} ${
-        getInstallationCommandFor(packageManager)
-      } ${[...new Set(dependencies)].join(' ')} --${getDependencyTypeFlag(packageManager, dependenciesType)}${
-        DEV_DEPENDENCY_TYPE === dependenciesType ? ` --${getExactFlag(packageManager)}` : ''
-      }`,
-      {shell: true, cwd: projectRoot}
-    );
-  } else warn(`No ${dependenciesType} dependencies to install`);
+async function isPackage ({packageDetails: {exports, publishConfig, bin}}) {
+  return !!exports || (!!publishConfig && !bin);
 }
 
-async function processDependencies ({dependencies = {}, devDependencies, projectRoot, packageManager}) {
-  info('Processing dependencies');
+const defaultBuildDirectory$1 = 'public';
 
-  if (Array.isArray(devDependencies)) {
-    throw new Error(
-      `devDependencies provided as: ${devDependencies}. Instead, provide under dependencies.javascript.development`
-    );
-  }
+async function scaffoldApplicationType ({projectRoot}) {
+  info('Scaffolding Application Details');
 
-  if (Array.isArray(dependencies)) {
-    throw new Error(`Expected dependencies to be an object. Instead received: ${dependencies}`);
-  }
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
 
-  const {javascript: {production = [], development = []} = {}} = dependencies;
+  const buildDirectory = defaultBuildDirectory$1;
 
-  try {
-    await install$1(production, PROD_DEPENDENCY_TYPE, projectRoot, packageManager);
-    await install$1(development, DEV_DEPENDENCY_TYPE, projectRoot, packageManager);
-  } catch (e) {
-    error('Failed to update dependencies');
-    error(e, {level: 'secondary'});
-  }
+  return {
+    scripts: {
+      clean: `rimraf ./${buildDirectory}`,
+      start: `node ./${buildDirectory}/index.js`,
+      prebuild: 'run-s clean'
+    },
+    dependencies: {javascript: {development: ['rimraf']}},
+    vcsIgnore: {files: ['.env'], directories: [`/${buildDirectory}/`]},
+    buildDirectory,
+    nextSteps: []
+  };
 }
 
-function projectWillBeTested(scripts) {
-  return Object.keys(scripts).find(scriptName => scriptName.startsWith('test:'));
+function isApplication ({packageDetails}) {
+  return !!packageDetails.private;
 }
 
-function projectShouldBeBuiltForVerification(scripts) {
-  return 'run-s build' === scripts['pregenerate:md'];
-}
+async function scaffoldMonorepoType ({projectRoot}) {
+  info('Scaffolding Monorepo Details');
 
-function updateTestScript (scripts) {
-  return {
-    ...scripts,
-    test: `npm-run-all --print-label${
-      projectShouldBeBuiltForVerification(scripts) ? ' build' : ''
-    } --parallel lint:*${
-      projectWillBeTested(scripts) ? ' --parallel test:*' : ''
-    }`
-  };
-}
+  await mergeIntoExistingPackageJson({projectRoot, config: {private: true}});
 
-function liftScripts ({existingScripts, scripts}) {
   return {
-    scripts: updateTestScript({...existingScripts, ...scripts}),
-    dependencies: {javascript: {development: ['npm-run-all2']}}
+    nextSteps: [{
+      summary: 'Add packages to your new monorepo',
+      description: 'Leverage [@form8ion/add-package-to-monorepo](https://npm.im/@form8ion/add-package-to-monorepo)'
+        + ' to scaffold new packages into your new monorepo'
+    }]
   };
 }
 
-async function liftPackage ({
+const defaultBuildDirectory = 'bin';
+
+async function scaffoldCliType ({
+  packageName,
+  visibility,
   projectRoot,
-  scripts,
-  tags,
-  dependencies,
-  devDependencies,
-  packageManager,
-  vcs,
-  pathWithinParent
+  dialect,
+  publishRegistry,
+  decisions,
+  packageBundlers
 }) {
-  info('Updating `package.json`', {level: 'secondary'});
-
-  const existingPackageJsonContents = JSON.parse(await promises$1.readFile(`${projectRoot}/package.json`, 'utf-8'));
-  const {scripts: liftedScripts, dependencies: scriptDependencies} = liftScripts({
-    existingScripts: existingPackageJsonContents.scripts,
-    scripts
-  });
-
-  await writePackageJson({
-    projectRoot,
-    config: sortPackageProperties({
-      ...existingPackageJsonContents,
-      ...defineVcsHostDetails(vcs, pathWithinParent),
-      scripts: liftedScripts,
-      ...tags && {
-        keywords: existingPackageJsonContents.keywords ? [...existingPackageJsonContents.keywords, ...tags] : tags
+  const packageAccessLevel = determinePackageAccessLevelFromProjectVisibility({projectVisibility: visibility});
+  const [bundlerResults, publishableResults] = await Promise.all([
+    scaffoldBundler({bundlers: packageBundlers, projectRoot, dialect, decisions, projectType: projectTypes$1.CLI}),
+    scaffoldPublishable({packageName, packageAccessLevel}),
+    mergeIntoExistingPackageJson({
+      projectRoot,
+      config: {
+        bin: {},
+        files: [`${defaultBuildDirectory}/`],
+        publishConfig: {
+          access: packageAccessLevel,
+          ...publishRegistry && {registry: publishRegistry}
+        }
       }
     })
-  });
+  ]);
 
-  await processDependencies({
-    dependencies: deepmerge(dependencies, scriptDependencies),
-    devDependencies,
-    projectRoot,
-    packageManager
-  });
+  return deepmerge.all([
+    publishableResults,
+    bundlerResults,
+    {
+      scripts: {
+        clean: `rimraf ./${defaultBuildDirectory}`,
+        prebuild: 'run-s clean',
+        build: 'npm-run-all --print-label --parallel build:*',
+        prepack: 'run-s build'
+      },
+      dependencies: {javascript: {production: ['update-notifier'], development: ['rimraf']}},
+      vcsIgnore: {files: [], directories: [`/${defaultBuildDirectory}/`]},
+      buildDirectory: defaultBuildDirectory,
+      nextSteps: [{summary: 'Define supported node.js versions as `engines.node` in the `package.json` file'}]
+    }
+  ]);
 }
 
-async function lift ({projectRoot, vcs, results, pathWithinParent, enhancers = {}, configs = {}}) {
-  info('Lifting JavaScript-specific details');
-
-  const {
-    scripts,
-    tags,
-    dependencies,
-    devDependencies,
-    packageManager: manager
-  } = results;
+async function isCli ({packageDetails: {bin}}) {
+  return !!bin;
+}
 
-  const [packageManager, packageContents] = await Promise.all([
-    resolvePackageManager({projectRoot, packageManager: manager}),
-    promises$1.readFile(`${projectRoot}/package.json`, 'utf8')
-  ]);
+function liftCli ({projectRoot, packageDetails}) {
+  return liftPublishable({projectRoot, packageDetails});
+}
 
-  const enhancerResults = await applyEnhancers({
-    results,
-    enhancers: {
-      ...enhancers,
-      huskyPlugin,
-      enginesEnhancer,
-      coveragePlugin,
-      commitConventionPlugin,
-      dialects,
-      codeStylePlugin,
-      npmConfigPlugin,
-      projectTypes,
-      packageManagers,
-      registriesPlugin
-    },
-    options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents), configs}
-  });
-
-  await liftPackage(
-    deepmerge.all([
-      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
-      enhancerResults
-    ])
-  );
-
-  return enhancerResults;
-}
-
-const scopeBasedConfigSchema = joi.object({scope: joi.string().regex(/^@[a-z0-9-]+$/i, 'scope').required()});
-
-const nameBasedConfigSchema = joi.object({
-  packageName: joi.string().required(),
-  name: joi.string().required()
-});
-
-const registriesSchema = joi.object().pattern(joi.string(), joi.string().uri()).default({});
-
-const visibilitySchema = joi.string().valid('Public', 'Private').required();
-
-const projectNameSchema = joi.string().regex(/^@\w*\//, {invert: true}).required();
-
-const vcsSchema = joi.object({
-  host: joi.string().required(),
-  owner: joi.string().required(),
-  name: joi.string().required()
-});
-
-function validate(options) {
-  const schema = joi.object({
-    projectRoot: joi.string().required(),
-    projectName: projectNameSchema,
-    visibility: visibilitySchema,
-    license: joi.string().required(),
-    description: joi.string(),
-    pathWithinParent: joi.string(),
-    decisions: joi.object(),
-    vcs: vcsSchema,
-    configs: joi.object({
-      eslint: scopeBasedConfigSchema,
-      typescript: scopeBasedConfigSchema,
-      prettier: scopeBasedConfigSchema,
-      commitlint: nameBasedConfigSchema,
-      babelPreset: nameBasedConfigSchema,
-      remark: joi.string(),
-      registries: registriesSchema
-    }).default({registries: {}}),
-    plugins: {
-      unitTestFrameworks: pluginsSchema,
-      packageBundlers: pluginsSchema,
-      applicationTypes: pluginsSchema,
-      packageTypes: pluginsSchema,
-      monorepoTypes: pluginsSchema,
-      hosts: pluginsSchema,
-      ciServices: pluginsSchema
-    }
-  }).required();
-
-  return validateOptions(schema, options);
-}
-
-function buildDialectChoices ({babelPreset, typescript}) {
-  return [
-    {name: 'Common JS (no transpilation)', value: dialects$1.COMMON_JS, short: 'cjs'},
-    ...babelPreset ? [{name: 'Modern JavaScript (transpiled)', value: dialects$1.BABEL, short: 'modern'}] : [],
-    {name: 'ESM-only (no transpilation)', value: dialects$1.ESM, short: 'esm'},
-    ...typescript ? [{name: 'TypeScript', value: dialects$1.TYPESCRIPT, short: 'ts'}] : []
-  ];
-}
-
-function projectIsCLI(answers) {
-  return projectTypes$1.CLI === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function projectIsPackage(answers) {
-  return projectTypes$1.PACKAGE === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function projectIsApplication(answers) {
-  return projectTypes$1.APPLICATION === answers[questionNames$1.PROJECT_TYPE];
-}
-
-function packageShouldBeScoped(visibility, answers) {
-  return 'Private' === visibility || answers[questionNames$1.SHOULD_BE_SCOPED];
-}
-
-function willBePublishedToNpm(answers) {
-  return projectIsPackage(answers) || projectIsCLI(answers);
-}
-
-function shouldBeScopedPromptShouldBePresented(answers) {
-  return willBePublishedToNpm(answers);
-}
-
-function scopePromptShouldBePresentedFactory(visibility) {
-  return answers => willBePublishedToNpm(answers) && packageShouldBeScoped(visibility, answers);
-}
-
-function lintingPromptShouldBePresented({
-  [questionNames$2.UNIT_TESTS]: unitTested,
-  [questionNames$2.INTEGRATION_TESTS]: integrationTested
-}) {
-  return !unitTested && !integrationTested;
-}
-
-function scope(visibility) {
-  return input => {
-    if (!input && 'Private' === visibility) {
-      return 'Private packages must be scoped (https://docs.npmjs.com/private-modules/intro#setting-up-your-package)';
-    }
-
-    return true;
-  };
-}
-
-function authorQuestions({name, email, url}) {
-  return [
-    {
-      name: questionNames$1.AUTHOR_NAME,
-      message: 'What is the author\'s name?',
-      default: name
-    },
-    {
-      name: questionNames$1.AUTHOR_EMAIL,
-      message: 'What is the author\'s email?',
-      default: email
-    },
-    {
-      name: questionNames$1.AUTHOR_URL,
-      message: 'What is the author\'s website url?',
-      default: url
-    }
-  ];
-}
-
-async function prompt(
-  ciServices,
-  hosts,
+async function scaffoldProjectType ({
+  projectType,
+  projectRoot,
+  projectName,
+  packageName,
+  packageManager,
   visibility,
-  vcs,
+  packageBundlers,
+  scope,
   decisions,
-  configs,
-  pathWithinParent
-) {
-  const npmConf$1 = npmConf();
-
-  let maybeLoggedInNpmUsername;
-  try {
-    maybeLoggedInNpmUsername = (await execa('npm', ['whoami'])).stdout;
-  } catch (failedExecutionResult) {
-    if (!decisions[questionNames$1.SCOPE]) {
-      warn('No logged in user found with `npm whoami`. Login with `npm login` '
-        + 'to use your npm account name as the package scope default.');
-    }
+  dialect,
+  provideExample,
+  publishRegistry
+}) {
+  switch (projectType) {
+    case projectTypes$1.PACKAGE:
+      return scaffoldPackageType({
+        projectRoot,
+        projectName,
+        packageName,
+        packageManager,
+        visibility,
+        scope,
+        packageBundlers,
+        decisions,
+        dialect,
+        provideExample,
+        publishRegistry
+      });
+    case projectTypes$1.APPLICATION:
+      return scaffoldApplicationType({projectRoot});
+    case projectTypes$1.CLI:
+      return scaffoldCliType({
+        packageName,
+        visibility,
+        projectRoot,
+        dialect,
+        publishRegistry,
+        decisions,
+        packageBundlers
+      });
+    case projectTypes$1.MONOREPO:
+      return scaffoldMonorepoType({projectRoot});
+    case 'Other':
+      return {};
+    default:
+      throw new Error(`The project-type of ${projectType} is invalid`);
   }
-
-  const {
-    [questionNames$2.UNIT_TESTS]: unitTested,
-    [questionNames$2.INTEGRATION_TESTS]: integrationTested,
-    [questionNames$1.PROJECT_TYPE]: projectType,
-    [questionNames$2.CI_SERVICE]: ci,
-    [questionNames$1.HOST]: chosenHost,
-    [questionNames$1.SCOPE]: scope$1,
-    [questionNames$1.NODE_VERSION_CATEGORY]: nodeVersionCategory,
-    [questionNames$1.AUTHOR_NAME]: authorName,
-    [questionNames$1.AUTHOR_EMAIL]: authorEmail,
-    [questionNames$1.AUTHOR_URL]: authorUrl,
-    [questionNames$1.CONFIGURE_LINTING]: configureLinting,
-    [questionNames$1.PROVIDE_EXAMPLE]: provideExample,
-    [questionNames$1.PACKAGE_MANAGER]: packageManager,
-    [questionNames$1.DIALECT]: dialect
-  } = await prompt$1([
-    {
-      name: questionNames$1.DIALECT,
-      message: 'Which JavaScript dialect should this project follow?',
-      type: 'list',
-      choices: buildDialectChoices(configs),
-      default: 'babel'
-    },
-    ...pathWithinParent ? [] : [{
-      name: questionNames$1.NODE_VERSION_CATEGORY,
-      message: 'What node.js version should be used?',
-      type: 'list',
-      choices: ['LTS', 'Latest'],
-      default: 'LTS'
-    }],
-    {
-      name: questionNames$1.PACKAGE_MANAGER,
-      message: 'Which package manager will be used with this project?',
-      type: 'list',
-      choices: Object.values(packageManagers$1),
-      default: packageManagers$1.NPM
-    },
-    {
-      name: questionNames$1.PROJECT_TYPE,
-      message: 'What type of JavaScript project is this?',
-      type: 'list',
-      choices: [...Object.values(projectTypes$1), 'Other'],
-      default: projectTypes$1.PACKAGE
-    },
-    ...'Private' === visibility ? [] : [{
-      name: questionNames$1.SHOULD_BE_SCOPED,
-      message: 'Should this package be scoped?',
-      type: 'confirm',
-      when: shouldBeScopedPromptShouldBePresented,
-      default: true
-    }],
-    {
-      name: questionNames$1.SCOPE,
-      message: 'What is the scope?',
-      when: scopePromptShouldBePresentedFactory(visibility),
-      validate: scope(visibility),
-      default: maybeLoggedInNpmUsername
-    },
-    ...authorQuestions({
-      name: npmConf$1.get('init.author.name'),
-      email: npmConf$1.get('init.author.email'),
-      url: npmConf$1.get('init.author.url')
-    }),
-    ...questions(({vcs, ciServices, pathWithinParent})),
-    {
-      name: questionNames$1.CONFIGURE_LINTING,
-      message: 'Will there be source code that should be linted?',
-      type: 'confirm',
-      when: lintingPromptShouldBePresented
-    },
-    {
-      name: questionNames$1.PROVIDE_EXAMPLE,
-      message: 'Should an example be provided in the README?',
-      type: 'confirm',
-      when: projectIsPackage
-    },
-    {
-      name: questionNames$1.HOST,
-      type: 'list',
-      message: 'Where will the application be hosted?',
-      when: projectIsApplication,
-      choices: [...Object.keys(hosts), 'Other']
-    }
-  ], decisions);
-
-  return {
-    tests: {unit: unitTested, integration: integrationTested},
-    projectType,
-    ci,
-    chosenHost,
-    scope: scope$1,
-    nodeVersionCategory,
-    author: {name: authorName, email: authorEmail, url: authorUrl},
-    configureLinting: false !== configureLinting,
-    provideExample,
-    packageManager,
-    dialect
-  };
 }
 
-function scaffoldDocumentation ({projectTypeResults, packageManager}) {
-  return {
-    toc: `Run \`${buildDocumentationCommand(packageManager)}\` to generate a table of contents`,
-    ...projectTypeResults.documentation,
-    contributing: `### Dependencies
-
-\`\`\`sh
-$ nvm install
-$ ${packageManager} install
-\`\`\`
-
-### Verification
-
-\`\`\`sh
-$ ${packageManager} test
-\`\`\``
-  };
-}
-
-function buildBadgesDetails (contributors) {
-  return deepmerge.all(contributors).badges;
-}
-
-async function determineLatestVersionOf(nodeVersionCategory) {
-  info('Determining version of node', {level: 'secondary'});
-
-  const {stdout: nvmLsOutput} = await execa(
-    `. ~/.nvm/nvm.sh && nvm ls-remote${('LTS' === nodeVersionCategory) ? ' --lts' : ''}`,
-    {shell: true}
-  );
-
-  const lsLines = nvmLsOutput.split('\n');
-  const lsLine = lsLines[lsLines.length - 2];
-
-  return lsLine.match(/(v[0-9]+)\.[0-9]+\.[0-9]+/)[1];
+async function tester$3 ({projectRoot, packageDetails}) {
+  return await isPackage({projectRoot, packageDetails})
+    || await isCli({projectRoot, packageDetails})
+    || isApplication({projectRoot, packageDetails});
 }
 
-function install(nodeVersionCategory) {
-  info(`Installing ${nodeVersionCategory} version of node using nvm`, {level: 'secondary'});
-
-  const subprocess = execa('. ~/.nvm/nvm.sh && nvm install', {shell: true});
-  subprocess.stdout.pipe(process.stdout);
-  return subprocess;
+function vcsRepositoryHostedOnGithub(vcs) {
+  return vcs && 'github' === vcs.host;
 }
 
-async function scaffoldNodeVersion ({projectRoot, nodeVersionCategory}) {
-  if (!nodeVersionCategory) return undefined;
-
-  const lowerCaseCategory = nodeVersionCategory.toLowerCase();
-  info(`Configuring ${lowerCaseCategory} version of node`);
-
-  const version = await determineLatestVersionOf(nodeVersionCategory);
+async function lifter$2 ({projectRoot, packageDetails, vcs}) {
+  if (await isPackage({projectRoot, packageDetails})) return liftPackage({projectRoot, packageDetails});
+  if (await isCli({projectRoot, packageDetails})) return liftCli({projectRoot, packageDetails});
 
-  await promises$1.writeFile(`${projectRoot}/.nvmrc`, version);
+  let homepage;
 
-  await install(nodeVersionCategory);
+  if (vcsRepositoryHostedOnGithub(vcs)) {
+    homepage = `https://github.com/${vcs.owner}/${vcs.name}#readme`;
 
-  return version;
-}
+    await mergeIntoExistingPackageJson({projectRoot, config: {homepage}});
+  }
 
-function nvmIsUsed ({projectRoot}) {
-  return fileExists(`${projectRoot}/.nvmrc`);
+  return {homepage};
 }
 
-function buildVcsIgnoreLists (vcsIgnoreLists = {}) {
-  return {
-    files: vcsIgnoreLists.files || [],
-    directories: ['/node_modules/', ...vcsIgnoreLists.directories || []]
-  };
-}
+var projectTypes = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter$2,
+  scaffold: scaffoldProjectType,
+  test: tester$3
+});
 
 async function chooseProjectTypePlugin ({types, projectType, decisions}) {
   if (!Object.keys(types).length) return 'Other';
@@ -1736,6 +1491,59 @@ async function scaffoldTesting ({
   );
 }
 
+function buildAllowedHostsList ({packageManager, registries = {}}) {
+  return [
+    ...!registries.registry ? [packageManager] : [],
+    ...Object.values(Object.fromEntries(Object.entries(registries).filter(([scope]) => 'publish' !== scope)))
+  ];
+}
+
+const lockfileLintSupportedPackageManagers = [packageManagers$1.NPM, packageManagers$1.YARN];
+
+function lockfileLintSupports(packageManager) {
+  return lockfileLintSupportedPackageManagers.includes(packageManager);
+}
+
+async function scaffoldLockfileLint ({projectRoot, packageManager, registries}) {
+  if (!lockfileLintSupports(packageManager)) {
+    throw new Error(
+      `The ${packageManager} package manager is currently not supported by lockfile-lint. `
+      + `Only ${lockfileLintSupportedPackageManagers.join(' and ')} are currently supported.`
+    );
+  }
+
+  await write$2({
+    name: 'lockfile-lint',
+    format: fileTypes.JSON,
+    path: projectRoot,
+    config: {
+      path: determineLockfilePathFor(packageManager),
+      type: packageManager,
+      'validate-https': true,
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+
+  return {
+    dependencies: {javascript: {development: ['lockfile-lint']}},
+    scripts: {'lint:lockfile': 'lockfile-lint'}
+  };
+}
+
+function lockfileLintIsAlreadyConfigured ({projectRoot}) {
+  return fileExists(`${projectRoot}/.lockfile-lintrc.json`);
+}
+
+const configName = 'lockfile-lint';
+
+function read({projectRoot}) {
+  return loadConfigFile({name: `.${configName}rc`, format: fileTypes.JSON, path: projectRoot});
+}
+
+function write({projectRoot, config}) {
+  return write$2({name: configName, format: fileTypes.JSON, path: projectRoot, config});
+}
+
 async function scaffoldLinting ({projectRoot, packageManager, registries}) {
   return scaffoldLockfileLint({projectRoot, packageManager, registries});
 }
@@ -1764,12 +1572,82 @@ async function scaffoldVerification({
       pathWithinParent
     }),
     scaffoldLinting({projectRoot, packageManager, registries, vcs, pathWithinParent}),
-    scaffold$3({projectRoot, packageManager, pathWithinParent})
+    scaffold$1({projectRoot, packageManager, pathWithinParent})
   ]);
 
   return deepmerge.all([testingResults, lintingResults, huskyResults]);
 }
 
+async function scaffoldRemark ({config, projectRoot, projectType, vcs}) {
+  await write$2({
+    format: fileTypes.JSON,
+    path: projectRoot,
+    name: 'remark',
+    config: {
+      settings: {
+        listItemIndent: 'one',
+        emphasis: '_',
+        strong: '_',
+        bullet: '*',
+        incrementListMarker: false
+      },
+      plugins: [
+        config,
+        ['remark-toc', {tight: true}],
+        ...projectTypes$1.PACKAGE === projectType ? [['remark-usage', {heading: 'example'}]] : [],
+        ...!vcs ? [['validate-links', {repository: false}]] : []
+      ]
+    }
+  });
+
+  return deepmerge(
+    {
+      dependencies: {javascript: {development: [config, 'remark-cli', 'remark-toc']}},
+      scripts: {
+        'lint:md': 'remark . --frail',
+        'generate:md': 'remark . --output'
+      }
+    },
+    {...projectTypes$1.PACKAGE === projectType && {dependencies: {javascript: {development: ['remark-usage']}}}}
+  );
+}
+
+async function scaffoldCodeStyle ({
+  projectRoot,
+  projectType,
+  configs,
+  vcs,
+  configureLinting
+}) {
+  return deepmerge.all(await Promise.all([
+    configs.eslint
+      && configureLinting
+      && scaffold$2({projectRoot, config: configs.eslint}),
+    scaffoldRemark({
+      projectRoot,
+      projectType,
+      vcs,
+      config: configs.remark || '@form8ion/remark-lint-preset'
+    }),
+    scaffold$3({projectRoot, config: configs.prettier})
+  ].filter(Boolean)));
+}
+
+function lifter$1 (options) {
+  return applyEnhancers({options, enhancers: [eslintPlugin]});
+}
+
+function tester$2 (options) {
+  return test$1(options);
+}
+
+var codeStylePlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter$1,
+  scaffold: scaffoldCodeStyle,
+  test: tester$2
+});
+
 async function scaffolder (options) {
   info('Initializing JavaScript project');
 
@@ -1897,25 +1775,133 @@ async function scaffolder (options) {
     projectTypePluginResults
   ]);
 
-  // const liftResults = await lift({
-  //   results: deepmerge({devDependencies: ['npm-run-all2'], packageManager}, mergedContributions),
-  //   projectRoot,
-  //   configs,
-  //   vcs,
-  //   pathWithinParent
-  // });
-
   return {
     ...mergedContributions,
-    badges: buildBadgesDetails([mergedContributions/*, liftResults*/]),
     documentation: scaffoldDocumentation({projectTypeResults, packageManager}),
     tags: projectTypeResults.tags,
     vcsIgnore: buildVcsIgnoreLists(mergedContributions.vcsIgnore),
-    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`,
-    // projectDetails: {...liftResults.homepage && {homepage: liftResults.homepage}},
+    verificationCommand: `${buildDocumentationCommand(packageManager)} && ${packageManager} test`
+  };
+}
+
+function tester$1 () {
+  return true;
+}
+
+function buildRegistriesConfig (registries = {}) {
+  return Object.entries(registries)
+    .filter(([scope]) => 'publish' !== scope)
+    .reduce((acc, [scope, url]) => {
+      if ('registry' === scope) return {...acc, registry: url};
+
+      return {...acc, [`@${scope}:registry`]: url};
+    }, {registry: 'https://registry.npmjs.org'});
+}
+
+async function updateRegistriesInNpmConfig(registries, projectRoot) {
+  const registriesForNpmConfig = buildRegistriesConfig(registries);
+
+  await writeNpmConfig({
+    projectRoot,
+    config: {
+      ...(await readNpmConfig({projectRoot})),
+      ...registriesForNpmConfig
+    }
+  });
+}
+
+async function updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries) {
+  await write({
+    projectRoot,
+    config: {
+      ...await read({projectRoot}),
+      'allowed-hosts': buildAllowedHostsList({packageManager, registries})
+    }
+  });
+}
+
+async function lifter ({projectRoot, packageManager, configs: {registries}}) {
+  await updateRegistriesInNpmConfig(registries, projectRoot);
+
+  if (!(await lockfileLintIsAlreadyConfigured({projectRoot}))) {
+    return scaffoldLockfileLint({projectRoot, packageManager, registries});
+  }
+
+  await updateRegistriesInLockfileLintConfig(projectRoot, packageManager, registries);
+
+  return {};
+}
+
+var registriesPlugin = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lifter,
+  test: tester$1
+});
+
+async function test({projectRoot}) {
+  const {engines} = JSON.parse(await promises.readFile(`${projectRoot}/package.json`, 'utf8'));
+
+  return !!engines?.node;
+}
+
+async function lift$1({packageDetails: {name}}) {
+  return {
+    dependencies: {javascript: {development: ['ls-engines']}},
+    scripts: {'lint:engines': 'ls-engines'},
+    badges: {consumer: {node: {img: `https://img.shields.io/node/v/${name}?logo=node.js`, text: 'node'}}}
   };
 }
 
+var enginesEnhancer = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  lift: lift$1,
+  test: test
+});
+
+async function lift ({projectRoot, vcs, results, pathWithinParent, enhancers = {}, configs = {}}) {
+  info('Lifting JavaScript-specific details');
+
+  const {
+    scripts,
+    tags,
+    dependencies,
+    devDependencies,
+    packageManager: manager
+  } = results;
+
+  const [packageManager, packageContents] = await Promise.all([
+    resolvePackageManager({projectRoot, packageManager: manager}),
+    promises$1.readFile(`${projectRoot}/package.json`, 'utf8')
+  ]);
+
+  const enhancerResults = await applyEnhancers({
+    results,
+    enhancers: {
+      ...enhancers,
+      huskyPlugin,
+      enginesEnhancer,
+      coveragePlugin,
+      commitConventionPlugin,
+      dialects,
+      codeStylePlugin,
+      npmConfigPlugin,
+      projectTypes,
+      packageManagers,
+      registriesPlugin
+    },
+    options: {packageManager, projectRoot, vcs, packageDetails: JSON.parse(packageContents), configs}
+  });
+
+  await liftPackage$1(
+    deepmerge.all([
+      {projectRoot, scripts, tags, dependencies, devDependencies, packageManager, vcs, pathWithinParent},
+      enhancerResults
+    ])
+  );
+
+  return enhancerResults;
+}
+
 async function tester ({projectRoot}) {
   const [nvmFound, jsPackageManagerFound] = await Promise.all([
     nvmIsUsed({projectRoot}),