@valbuild/shared 0.148.6 → 0.149.7

package/typecheck/dist/valbuild-shared-typecheck.cjs.dev.js

@@ -0,0 +1,1173 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var slicedToArray = require('../../dist/slicedToArray-62e428df.cjs.dev.js');
+var createForOfIteratorHelper = require('../../dist/createForOfIteratorHelper-d86bb352.cjs.dev.js');
+var yaml = require('yaml');
+var acquireTypes = require('../../dist/acquireTypes-de10005d.cjs.dev.js');
+var proposalProject = require('../../dist/proposalProject-cdc53711.cjs.dev.js');
+
+function _regeneratorValues(e) {
+  if (null != e) {
+    var t = e["function" == typeof Symbol && Symbol.iterator || "@@iterator"],
+      r = 0;
+    if (t) return t.call(e);
+    if ("function" == typeof e.next) return e;
+    if (!isNaN(e.length)) return {
+      next: function () {
+        return e && r >= e.length && (e = void 0), {
+          value: e && e[r++],
+          done: !e
+        };
+      }
+    };
+  }
+  throw new TypeError(typeof e + " is not iterable");
+}
+
+/**
+ * Read straight from a pnpm lockfile's text, with no YAML parser: what
+ * `/val/adept` lists, and which TypeScript the typecheck loads.
+ * `pnpmLockfile.ts` is the full reader.
+ */
+
+/** The registry packages a pnpm 9 lockfile's `packages:` section names. */
+function lockedPackages(lockfile) {
+  var out = [];
+  var inPackages = false;
+  var current = null;
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(lockfile.split("\n")),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var line = _step.value;
+      if (/^\S/.test(line)) {
+        inPackages = line.startsWith("packages:");
+        current = null;
+        continue;
+      }
+      if (!inPackages) continue;
+      var head = /^ {2}['"]?(.+?)['"]?:\s*$/.exec(line);
+      if (head) {
+        var key = head[1];
+        var at = key.lastIndexOf("@");
+        var version = key.slice(at + 1);
+        current = null;
+        if (at > 0 && /^\d+\.\d+\.\d+/.test(version)) {
+          current = {
+            name: key.slice(0, at),
+            version: version
+          };
+          out.push(current);
+        }
+        continue;
+      }
+      var integrity = /integrity: (sha512-[^,}\s]+)/.exec(line);
+      if (current && integrity) current.integrity = integrity[1];
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return out;
+}
+
+/** The version the root importer's lockfile entry gives `typescript`. */
+function typescriptVersion(lockfile) {
+  var _exec$, _exec;
+  var start = lockfile.indexOf("\n  .:\n");
+  if (start < 0) return null;
+  var end = lockfile.indexOf("\n\n", start + 1);
+  var root = lockfile.slice(start, end < 0 ? undefined : end);
+  return (_exec$ = (_exec = /\n {6}typescript:\n {8}specifier: [^\n]+\n {8}version: (\d+\.\d+\.\d+[^\s(]*)/.exec(root)) === null || _exec === void 0 ? void 0 : _exec[1]) !== null && _exec$ !== void 0 ? _exec$ : null;
+}
+
+/** The TypeScript API, from whichever `typescript.js` was loaded. */
+
+/** adept's `/compiler/<version>`: `lib/typescript.js` and every `lib/lib.*.d.ts`. */
+
+/**
+ * The TypeScript a project gets when its own cannot run here.
+ *
+ * TypeScript 7 and later are a native compiler with no JavaScript one
+ * (`lib/typescript.js`), so they cannot run in a browser; a project with no
+ * `typescript` at all has none to choose. Both are checked with this 6.x,
+ * the one the Studio itself is built and tested with
+ * (`typescriptCompiler.test.ts` keeps the two the same). It is fetched from
+ * adept like any other, rather than shipped in the Studio's bundle, which is
+ * embedded in every Val server.
+ */
+var BUNDLED_TYPESCRIPT = "6.0.3";
+
+/** Which TypeScript checks a project, and why that one. */
+
+function chooseCompiler(wanted) {
+  var _exec$, _exec;
+  if (wanted === null) {
+    return {
+      version: BUNDLED_TYPESCRIPT,
+      wanted: wanted,
+      reason: "no-typescript"
+    };
+  }
+  var major = Number((_exec$ = (_exec = /^(\d+)\./.exec(wanted)) === null || _exec === void 0 ? void 0 : _exec[1]) !== null && _exec$ !== void 0 ? _exec$ : NaN);
+  if (major >= 7) {
+    return {
+      version: BUNDLED_TYPESCRIPT,
+      wanted: wanted,
+      reason: "no-js-compiler"
+    };
+  }
+  return {
+    version: wanted,
+    wanted: wanted,
+    reason: "project"
+  };
+}
+
+/**
+ * Whether `value` is the TypeScript API. Checked by the functions this
+ * typechecker calls, which every version since 4 has.
+ */
+function isTypeScript(value) {
+  if (createForOfIteratorHelper._typeof(value) !== "object" || value === null) return false;
+  return ["createLanguageService", "createDocumentRegistry", "parseJsonConfigFileContent", "readConfigFile", "preProcessFile", "getPreEmitDiagnostics", "flattenDiagnosticMessageText", "getDefaultLibFileName", "sortAndDeduplicateDiagnostics"].every(function (name) {
+    return typeof Reflect.get(value, name) === "function";
+  });
+}
+
+/** A TypeScript that does not have what a typecheck needs. */
+var CompilerError = /*#__PURE__*/function (_Error) {
+  function CompilerError() {
+    slicedToArray._classCallCheck(this, CompilerError);
+    return slicedToArray._callSuper(this, CompilerError, arguments);
+  }
+  slicedToArray._inherits(CompilerError, _Error);
+  return slicedToArray._createClass(CompilerError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+
+/**
+ * Evaluates `lib/typescript.js` and returns its API.
+ *
+ * It is a CommonJS module that also runs as a plain script, so it is given a
+ * `module` to assign to. `require` and `process` are given as `undefined`,
+ * as they are in a worker, so that it does not build a Node `ts.sys` when it
+ * runs under Node: everything it reads goes through the host this
+ * typechecker gives it.
+ */
+function evaluateTypeScript(source) {
+  var module = {
+    exports: {}
+  };
+  // The compiler is text fetched at run time: evaluating it is the point.
+  var run = new Function("module", "exports", "require", "process", "__filename", "__dirname", source);
+  run(module, module.exports, undefined, undefined, undefined, undefined);
+  if (!isTypeScript(module.exports)) {
+    throw new CompilerError("lib/typescript.js did not give the TypeScript API this typecheck needs.");
+  }
+  return module.exports;
+}
+
+/**
+ * `ts.matchFiles`, which is how `tsc` expands a tsconfig's `include` and
+ * `exclude`. It is internal, but every `typescript.js` since 2.x has it on
+ * its API object, and using it is the only way to agree with `tsc` on hidden
+ * files, `node_modules` and implicit directory globs.
+ */
+
+function isStringArray(value) {
+  return Array.isArray(value) && value.every(function (item) {
+    return typeof item === "string";
+  });
+}
+function matchFilesOf(ts) {
+  var internal = Reflect.get(ts, "matchFiles");
+  if (typeof internal !== "function") {
+    throw new CompilerError("TypeScript ".concat(ts.version, " has no matchFiles, so its tsconfig include patterns cannot be read here."));
+  }
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var files = Reflect.apply(internal, ts, args);
+    if (!isStringArray(files)) {
+      throw new CompilerError("TypeScript ".concat(ts.version, "'s matchFiles did not answer with file names."));
+    }
+    return files;
+  };
+}
+
+/**
+ * The type errors a project would have after `pnpm install`, computed in
+ * memory: the layout from the lockfile, the types its imports reach from
+ * adept, and the project's own TypeScript over both. See `docs` in
+ * valbuild/home's `adept.md`, step 4.
+ */
+
+/** The project's root in the file system the checker builds. */
+var PROJECT_ROOT = "/project";
+var COMPILER_ROOT = "/typescript";
+
+/**
+ * At most this many rounds of "build the programs, fetch what TypeScript
+ * looked for and did not find". Each round fetches only what the round
+ * before uncovered, so this is a guard against a loop, not a budget: the
+ * templates need one or two.
+ */
+var MAX_RESOLUTION_ROUNDS = 8;
+
+/** A tsconfig and the program it describes. */
+
+function isRecord$1(value) {
+  return createForOfIteratorHelper._typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+var relative = function relative(path) {
+  return path === PROJECT_ROOT ? "." : path.startsWith("".concat(PROJECT_ROOT, "/")) ? path.slice(PROJECT_ROOT.length + 1) : path;
+};
+
+/**
+ * Every `tsconfig.json` in the project, and every config their `references`
+ * name, in a stable order. A solution-style config (no files of its own,
+ * only references) is not a program; the configs it references are.
+ */
+function readConfigs(ts, fs, projectFiles) {
+  var matchFiles = matchFilesOf(ts);
+  var host = {
+    useCaseSensitiveFileNames: true,
+    fileExists: function fileExists(path) {
+      return fs.fileExists(path);
+    },
+    readFile: function readFile(path) {
+      return fs.readFile(path);
+    },
+    readDirectory: function readDirectory(root, extensions, excludes, includes, depth) {
+      return matchFiles(root, extensions, excludes, includes, true, PROJECT_ROOT, depth, function (path) {
+        return {
+          files: fs.getFiles(path),
+          directories: fs.getDirectories(path)
+        };
+      }, function (path) {
+        return fs.realpath(path);
+      });
+    }
+  };
+  var queue = projectFiles.filter(function (path) {
+    return path.endsWith("/tsconfig.json") && !path.includes("/node_modules/");
+  }).sort();
+  var seen = new Set();
+  var configs = [];
+  for (var path = queue.shift(); path !== undefined; path = queue.shift()) {
+    var _parsed$projectRefere, _parsed$projectRefere2, _parsed$projectRefere3;
+    if (seen.has(path)) continue;
+    seen.add(path);
+    var read = ts.readConfigFile(path, function (file) {
+      return fs.readFile(file);
+    });
+    var dir = acquireTypes.parentOf(path);
+    if (read.error) {
+      configs.push({
+        path: path,
+        options: {},
+        rootNames: [],
+        projectReferences: undefined,
+        errors: [read.error]
+      });
+      continue;
+    }
+    var parsed = ts.parseJsonConfigFileContent(read.config, host, dir, undefined, path);
+    var _iterator = createForOfIteratorHelper._createForOfIteratorHelper((_parsed$projectRefere3 = parsed.projectReferences) !== null && _parsed$projectRefere3 !== void 0 ? _parsed$projectRefere3 : []),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var reference = _step.value;
+        var target = acquireTypes.normalizePath(reference.path);
+        queue.push(target.endsWith(".json") ? target : "".concat(target, "/tsconfig.json"));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    var solutionOnly = parsed.fileNames.length === 0 && ((_parsed$projectRefere = (_parsed$projectRefere2 = parsed.projectReferences) === null || _parsed$projectRefere2 === void 0 ? void 0 : _parsed$projectRefere2.length) !== null && _parsed$projectRefere !== void 0 ? _parsed$projectRefere : 0) > 0;
+    if (solutionOnly) continue;
+    configs.push({
+      path: path,
+      options: parsed.options,
+      rootNames: parsed.fileNames,
+      projectReferences: parsed.projectReferences,
+      errors: parsed.errors
+    });
+  }
+  return configs;
+}
+
+/** A language service over the in-memory files, for one tsconfig. */
+function languageServiceFor(ts, fs, config, registry) {
+  var snapshots = new Map();
+  var host = {
+    getCompilationSettings: function getCompilationSettings() {
+      return config.options;
+    },
+    getScriptFileNames: function getScriptFileNames() {
+      return config.rootNames;
+    },
+    getProjectReferences: function getProjectReferences() {
+      return config.projectReferences;
+    },
+    // Nothing changes while a check runs: every file is at its first version.
+    getScriptVersion: function getScriptVersion() {
+      return "1";
+    },
+    getScriptSnapshot: function getScriptSnapshot(fileName) {
+      var snapshot = snapshots.get(fileName);
+      if (snapshot === undefined) {
+        var text = fs.readFile(fileName);
+        if (text === undefined) return undefined;
+        snapshot = ts.ScriptSnapshot.fromString(text);
+        snapshots.set(fileName, snapshot);
+      }
+      return snapshot;
+    },
+    getCurrentDirectory: function getCurrentDirectory() {
+      return PROJECT_ROOT;
+    },
+    getDefaultLibFileName: function getDefaultLibFileName(options) {
+      return "".concat(COMPILER_ROOT, "/lib/").concat(ts.getDefaultLibFileName(options));
+    },
+    fileExists: function fileExists(path) {
+      return fs.fileExists(path);
+    },
+    readFile: function readFile(path) {
+      return fs.readFile(path);
+    },
+    directoryExists: function directoryExists(path) {
+      return fs.directoryExists(path);
+    },
+    getDirectories: function getDirectories(path) {
+      return fs.getDirectories(path);
+    },
+    realpath: function realpath(path) {
+      return fs.realpath(path);
+    },
+    useCaseSensitiveFileNames: function useCaseSensitiveFileNames() {
+      return true;
+    }
+  };
+  return ts.createLanguageService(host, registry);
+}
+
+/**
+ * The diagnostics `tsc --noEmit -p <config>` prints: the config's own, then
+ * `getPreEmitDiagnostics` (options, global, syntactic, semantic, and
+ * declaration ones when the config emits declarations), sorted and
+ * deduplicated as `tsc` does.
+ */
+function diagnosticsOf(ts, program, config) {
+  var all = ts.sortAndDeduplicateDiagnostics([].concat(slicedToArray._toConsumableArray(config.errors), slicedToArray._toConsumableArray(ts.getPreEmitDiagnostics(program))));
+  return all.filter(function (d) {
+    return d.category === ts.DiagnosticCategory.Error;
+  }).map(function (d) {
+    var position = d.file && d.start !== undefined ? d.file.getLineAndCharacterOfPosition(d.start) : null;
+    return {
+      file: d.file ? relative(d.file.fileName) : null,
+      line: position ? position.line + 1 : null,
+      column: position ? position.character + 1 : null,
+      code: d.code,
+      message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+      tsconfig: relative(config.path)
+    };
+  });
+}
+
+/**
+ * Compilers already evaluated, by version: a worker that checks the base and
+ * then the upgrade evaluates 9 MB of `typescript.js` once.
+ */
+var evaluated = new Map();
+var elapsed = function elapsed(since) {
+  return Math.round(performance.now() - since);
+};
+
+/** Each workspace project's package name, which the hoist needs and the lockfile lacks. */
+function workspaceNamesOf(lockfile, files) {
+  var names = {};
+  for (var _i = 0, _Object$keys = Object.keys(lockfile.importers); _i < _Object$keys.length; _i++) {
+    var id = _Object$keys[_i];
+    var text = files[id === "." ? "package.json" : "".concat(id, "/package.json")];
+    if (text === undefined) continue;
+    try {
+      var manifest = JSON.parse(text);
+      if (isRecord$1(manifest) && typeof manifest["name"] === "string") {
+        names[id] = manifest["name"];
+      }
+    } catch (_unused) {
+      // A package.json that is not JSON has no name to hoist; the
+      // typecheck itself reports it if anything reads it.
+    }
+  }
+  return names;
+}
+function layoutOf(input) {
+  var lockfile = acquireTypes.parsePnpmLockfile(input.lockfile);
+  var workspace = input.workspace ? yaml.parse(input.workspace) : {};
+  var layout = acquireTypes.computePnpmLayout(lockfile, createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, acquireTypes.layoutOptionsOfWorkspace(isRecord$1(workspace) ? workspace : {})), {}, {
+    root: PROJECT_ROOT,
+    workspaceNames: workspaceNamesOf(lockfile, input.files)
+  }));
+  return {
+    lockfile: lockfile,
+    layout: layout
+  };
+}
+
+/** Typechecks a project as it would be after `pnpm install`. */
+function typecheckProject(_x) {
+  return _typecheckProject.apply(this, arguments);
+}
+function _typecheckProject() {
+  _typecheckProject = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(input) {
+    var _input$onProgress;
+    var started, progress, layoutStarted, _layoutOf, layout, layoutMs, compilerStarted, wanted, choice, compiler, source, ts, compilerMs, fs, _i2, _Object$entries, _Object$entries$_i, path, text, projectFiles, _i3, _Object$entries2, _Object$entries2$_i, _path, _text, absolute, typesStarted, configs, acquisition, reportFetching, _iterator3, _step3, _config$options$types, config, dir, _iterator5, _step5, name, _text2, _iterator6, _step6, types, jsxSource, registry, rounds, _loop, typesMs, checkStarted, errors, programs, _iterator4, _step4, _config2, service, program, found, sourceFiles, checkMs, stats, _t, _t2;
+    return slicedToArray._regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
+        case 0:
+          started = performance.now();
+          progress = (_input$onProgress = input.onProgress) !== null && _input$onProgress !== void 0 ? _input$onProgress : function () {};
+          progress({
+            step: "layout"
+          });
+          layoutStarted = performance.now();
+          _layoutOf = layoutOf(input), layout = _layoutOf.layout;
+          layoutMs = elapsed(layoutStarted);
+          compilerStarted = performance.now();
+          wanted = typescriptVersion(input.lockfile);
+          choice = chooseCompiler(wanted);
+          progress({
+            step: "compiler",
+            version: choice.version
+          });
+          _context2.p = 1;
+          _context2.n = 2;
+          return input.sources.compiler(choice.version);
+        case 2:
+          compiler = _context2.v;
+          _context2.n = 6;
+          break;
+        case 3:
+          _context2.p = 3;
+          _t = _context2.v;
+          if (!(!(_t instanceof acquireTypes.SourceError) || _t.code !== "no-js-compiler" || choice.reason !== "project")) {
+            _context2.n = 4;
+            break;
+          }
+          throw _t;
+        case 4:
+          choice = {
+            version: BUNDLED_TYPESCRIPT,
+            wanted: wanted,
+            reason: "no-js-compiler"
+          };
+          progress({
+            step: "compiler",
+            version: choice.version
+          });
+          _context2.n = 5;
+          return input.sources.compiler(choice.version);
+        case 5:
+          compiler = _context2.v;
+        case 6:
+          source = compiler.files["lib/typescript.js"];
+          if (!(source === undefined)) {
+            _context2.n = 7;
+            break;
+          }
+          throw new acquireTypes.SourceError("adept's TypeScript ".concat(choice.version, " came without lib/typescript.js."), "unexpected-answer", false);
+        case 7:
+          ts = evaluated.get(choice.version);
+          if (ts === undefined) {
+            ts = evaluateTypeScript(source);
+            evaluated.set(choice.version, ts);
+          }
+          compilerMs = elapsed(compilerStarted);
+          fs = new acquireTypes.LinkedFileSystem(layout.links);
+          for (_i2 = 0, _Object$entries = Object.entries(compiler.files); _i2 < _Object$entries.length; _i2++) {
+            _Object$entries$_i = slicedToArray._slicedToArray(_Object$entries[_i2], 2), path = _Object$entries$_i[0], text = _Object$entries$_i[1];
+            if (path.startsWith("lib/") && path.endsWith(".d.ts")) {
+              fs.writeFile("".concat(COMPILER_ROOT, "/").concat(path), text);
+            }
+          }
+          projectFiles = [];
+          _i3 = 0, _Object$entries2 = Object.entries(input.files);
+        case 8:
+          if (!(_i3 < _Object$entries2.length)) {
+            _context2.n = 11;
+            break;
+          }
+          _Object$entries2$_i = slicedToArray._slicedToArray(_Object$entries2[_i3], 2), _path = _Object$entries2$_i[0], _text = _Object$entries2$_i[1];
+          absolute = acquireTypes.normalizePath("".concat(PROJECT_ROOT, "/").concat(_path));
+          if (!absolute.includes("/node_modules/")) {
+            _context2.n = 9;
+            break;
+          }
+          return _context2.a(3, 10);
+        case 9:
+          fs.writeFile(absolute, _text);
+          projectFiles.push(absolute);
+        case 10:
+          _i3++;
+          _context2.n = 8;
+          break;
+        case 11:
+          typesStarted = performance.now();
+          configs = readConfigs(ts, fs, projectFiles);
+          acquisition = new acquireTypes.TypeAcquisition(ts, fs, layout, input.sources);
+          reportFetching = function reportFetching() {
+            return progress({
+              step: "types",
+              fetched: acquisition.stats.scanned + acquisition.stats.resolved
+            });
+          };
+          _iterator3 = createForOfIteratorHelper._createForOfIteratorHelper(configs);
+          try {
+            for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+              config = _step3.value;
+              dir = acquireTypes.parentOf(config.path);
+              _iterator5 = createForOfIteratorHelper._createForOfIteratorHelper(config.rootNames);
+              try {
+                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+                  name = _step5.value;
+                  _text2 = fs.readFile(name);
+                  if (_text2 !== undefined) acquisition.wantImportsOf(name, _text2);
+                }
+              } catch (err) {
+                _iterator5.e(err);
+              } finally {
+                _iterator5.f();
+              }
+              _iterator6 = createForOfIteratorHelper._createForOfIteratorHelper((_config$options$types = config.options.types) !== null && _config$options$types !== void 0 ? _config$options$types : []);
+              try {
+                for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                  types = _step6.value;
+                  acquisition.wantSpecifier(dir, types);
+                }
+              } catch (err) {
+                _iterator6.e(err);
+              } finally {
+                _iterator6.f();
+              }
+              jsxSource = config.options.jsxImportSource;
+              if (jsxSource) acquisition.wantSpecifier(dir, "".concat(jsxSource, "/jsx-runtime"));
+            }
+          } catch (err) {
+            _iterator3.e(err);
+          } finally {
+            _iterator3.f();
+          }
+          reportFetching();
+          _context2.n = 12;
+          return acquisition.settle();
+        case 12:
+          /*
+           * The scan finds what the imports name. TypeScript also looks where no
+           * import says: `@types` for an untyped package, `typeRoots`, a package's
+           * `typesVersions` and peers. So the programs are built, every package
+           * TypeScript looked in and that is not fetched yet is fetched, and again,
+           * until a round looks nowhere new.
+           */
+          registry = ts.createDocumentRegistry(true, PROJECT_ROOT);
+          rounds = 0;
+          _loop = /*#__PURE__*/slicedToArray._regenerator().m(function _loop() {
+            var looked, _iterator7, _step7, _config, _iterator8, _step8, _dir;
+            return slicedToArray._regenerator().w(function (_context) {
+              while (1) switch (_context.n) {
+                case 0:
+                  looked = new Set();
+                  fs.onLookup = function (real) {
+                    var dir = acquireTypes.packageDirOf(real);
+                    if (dir !== null && !acquisition.has(dir) && acquisition.packageAt(dir)) {
+                      looked.add(dir);
+                    }
+                  };
+                  _iterator7 = createForOfIteratorHelper._createForOfIteratorHelper(configs);
+                  try {
+                    for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+                      _config = _step7.value;
+                      languageServiceFor(ts, fs, _config, registry).getProgram();
+                    }
+                  } catch (err) {
+                    _iterator7.e(err);
+                  } finally {
+                    _iterator7.f();
+                  }
+                  fs.onLookup = null;
+                  if (!(looked.size === 0)) {
+                    _context.n = 1;
+                    break;
+                  }
+                  return _context.a(2, 1);
+                case 1:
+                  _iterator8 = createForOfIteratorHelper._createForOfIteratorHelper(looked);
+                  try {
+                    for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+                      _dir = _step8.value;
+                      acquisition.wantPackage(_dir, "resolved");
+                    }
+                  } catch (err) {
+                    _iterator8.e(err);
+                  } finally {
+                    _iterator8.f();
+                  }
+                  reportFetching();
+                  _context.n = 2;
+                  return acquisition.settle();
+                case 2:
+                  return _context.a(2);
+              }
+            }, _loop);
+          });
+        case 13:
+          if (!(rounds < MAX_RESOLUTION_ROUNDS)) {
+            _context2.n = 16;
+            break;
+          }
+          return _context2.d(_regeneratorValues(_loop()), 14);
+        case 14:
+          if (!_context2.v) {
+            _context2.n = 15;
+            break;
+          }
+          return _context2.a(3, 16);
+        case 15:
+          rounds++;
+          _context2.n = 13;
+          break;
+        case 16:
+          typesMs = elapsed(typesStarted);
+          checkStarted = performance.now();
+          errors = [];
+          programs = [];
+          _iterator4 = createForOfIteratorHelper._createForOfIteratorHelper(configs);
+          _context2.p = 17;
+          _iterator4.s();
+        case 18:
+          if ((_step4 = _iterator4.n()).done) {
+            _context2.n = 21;
+            break;
+          }
+          _config2 = _step4.value;
+          progress({
+            step: "check",
+            tsconfig: relative(_config2.path)
+          });
+          service = languageServiceFor(ts, fs, _config2, registry);
+          program = service.getProgram();
+          if (program) {
+            _context2.n = 19;
+            break;
+          }
+          return _context2.a(3, 20);
+        case 19:
+          found = diagnosticsOf(ts, program, _config2);
+          errors.push.apply(errors, slicedToArray._toConsumableArray(found));
+          sourceFiles = program.getSourceFiles();
+          programs.push(createForOfIteratorHelper._objectSpread2({
+            tsconfig: relative(_config2.path),
+            files: sourceFiles.length,
+            errors: found.length
+          }, input.listFiles ? {
+            fileNames: sourceFiles.map(function (file) {
+              return relative(file.fileName);
+            })
+          } : {}));
+          service.dispose();
+        case 20:
+          _context2.n = 18;
+          break;
+        case 21:
+          _context2.n = 23;
+          break;
+        case 22:
+          _context2.p = 22;
+          _t2 = _context2.v;
+          _iterator4.e(_t2);
+        case 23:
+          _context2.p = 23;
+          _iterator4.f();
+          return _context2.f(23);
+        case 24:
+          checkMs = elapsed(checkStarted);
+          stats = acquisition.stats;
+          return _context2.a(2, {
+            errors: errors,
+            programs: programs,
+            typescript: choice,
+            bundles: createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, stats), {}, {
+              count: stats.scanned + stats.resolved,
+              rounds: rounds
+            }),
+            missing: acquisition.missing,
+            timings: {
+              layoutMs: layoutMs,
+              compilerMs: compilerMs,
+              typesMs: typesMs,
+              checkMs: checkMs,
+              totalMs: elapsed(started)
+            }
+          });
+      }
+    }, _callee, null, [[17, 22, 23, 24], [1, 3]]);
+  }));
+  return _typecheckProject.apply(this, arguments);
+}
+var errorKey = function errorKey(error) {
+  var _error$file;
+  return "".concat((_error$file = error.file) !== null && _error$file !== void 0 ? _error$file : "", "\0").concat(error.code, "\0").concat(error.message);
+};
+
+/**
+ * The errors of `next` that `base` does not have (decision 20): an upgrade
+ * is judged only by the errors it adds. Errors are matched by file, code and
+ * message, not by position, so that an error which only moved is not new;
+ * and counted, so that a second copy of an error the base has once is.
+ */
+function newErrors(base, next) {
+  var remaining = new Map();
+  var _iterator2 = createForOfIteratorHelper._createForOfIteratorHelper(base),
+    _step2;
+  try {
+    for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+      var _remaining$get2;
+      var error = _step2.value;
+      var key = errorKey(error);
+      remaining.set(key, ((_remaining$get2 = remaining.get(key)) !== null && _remaining$get2 !== void 0 ? _remaining$get2 : 0) + 1);
+    }
+  } catch (err) {
+    _iterator2.e(err);
+  } finally {
+    _iterator2.f();
+  }
+  return next.filter(function (error) {
+    var _remaining$get;
+    var key = errorKey(error);
+    var left = (_remaining$get = remaining.get(key)) !== null && _remaining$get !== void 0 ? _remaining$get : 0;
+    if (left === 0) return true;
+    remaining.set(key, left - 1);
+    return false;
+  });
+}
+
+/**
+ * Type bundles and compilers from adept, by way of whoever proxies to it:
+ *
+ * - The Studio: `base` is `/api/val/publish-api/adept`, its own server, which
+ *   proxies to content with the session (`STUDIO_ADEPT_BASE` in
+ *   `@valbuild/ui`).
+ * - Home's upgrade page: `base` is content's `/v1/adept`, called with the
+ *   person's own credential in `headers` (valbuild/home
+ *   `docs/plans/upgrades-v2.md`, piece E).
+ * - adept itself (`http://127.0.0.1:4300/v1`), which is how the parity script
+ *   runs.
+ *
+ * Both answers are immutable: a route that passes them on with their headers
+ * lets the browser answer repeats from its cache.
+ */
+function isRecord(value) {
+  return createForOfIteratorHelper._typeof(value) === "object" && value !== null && !Array.isArray(value);
+}
+function isTextFiles(value) {
+  return isRecord(value) && Object.values(value).every(function (v) {
+    return typeof v === "string";
+  });
+}
+
+/** An answer that was not a success: what it said, and its status. */
+var AnswerError = /*#__PURE__*/function (_Error) {
+  function AnswerError(statusCode, message, body) {
+    var _this;
+    slicedToArray._classCallCheck(this, AnswerError);
+    _this = slicedToArray._callSuper(this, AnswerError, [message]);
+    _this.statusCode = statusCode;
+    _this.body = body;
+    return _this;
+  }
+  slicedToArray._inherits(AnswerError, _Error);
+  return slicedToArray._createClass(AnswerError);
+}(/*#__PURE__*/slicedToArray._wrapNativeSuper(Error));
+/** Not now: a timeout, too many requests, a server or gateway error. */
+var isTransient = function isTransient(status) {
+  return status >= 500 || status === 408 || status === 429;
+};
+
+/** adept's `{ error: { code, message, retryable } }`, or what else went wrong. */
+function sourceErrorOf(error, what) {
+  if (error instanceof AnswerError) {
+    var _body = isRecord(error.body) ? error.body["error"] : undefined;
+    if (isRecord(_body) && typeof _body["message"] === "string") {
+      return new acquireTypes.SourceError(_body["message"], typeof _body["code"] === "string" ? _body["code"] : String(error.statusCode), _body["retryable"] === true, error.statusCode);
+    }
+    return new acquireTypes.SourceError("".concat(what, ": ").concat(error.message), String(error.statusCode),
+    // 501 is a deployment with no content service to ask: asking again
+    // gets the same answer.
+    isTransient(error.statusCode) && error.statusCode !== 501, error.statusCode);
+  }
+  return new acquireTypes.SourceError("".concat(what, " could not be fetched: ").concat(error instanceof Error ? error.message : String(error)), "network", true);
+}
+
+/**
+ * One GET, as JSON. A body that is not JSON is a gateway, not adept or content
+ * answering, so it is `undefined` and the status carries the meaning.
+ */
+function getJson(_x, _x2, _x3) {
+  return _getJson.apply(this, arguments);
+}
+function _getJson() {
+  _getJson = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee4(fetchImpl, url, init) {
+    var res, text, parsed, message;
+    return slicedToArray._regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
+        case 0:
+          _context4.n = 1;
+          return fetchImpl(url, createForOfIteratorHelper._objectSpread2(createForOfIteratorHelper._objectSpread2({}, init), {}, {
+            method: "GET"
+          }));
+        case 1:
+          res = _context4.v;
+          _context4.n = 2;
+          return res.text();
+        case 2:
+          text = _context4.v;
+          try {
+            parsed = text === "" ? undefined : JSON.parse(text);
+          } catch (_unused) {
+            parsed = undefined;
+          }
+          if (res.ok) {
+            _context4.n = 3;
+            break;
+          }
+          message = isRecord(parsed) && typeof parsed["message"] === "string" ? parsed["message"] : "The answer was ".concat(res.status, ".");
+          throw new AnswerError(res.status, message, parsed);
+        case 3:
+          return _context4.a(2, parsed);
+      }
+    }, _callee4);
+  }));
+  return _getJson.apply(this, arguments);
+}
+function adeptSources(options) {
+  var _options$fetch, _options$credentials;
+  var fetchImpl = (_options$fetch = options.fetch) !== null && _options$fetch !== void 0 ? _options$fetch : function () {
+    return fetch.apply(void 0, arguments);
+  };
+  var init = createForOfIteratorHelper._objectSpread2({
+    credentials: (_options$credentials = options.credentials) !== null && _options$credentials !== void 0 ? _options$credentials : "same-origin"
+  }, options.headers ? {
+    headers: options.headers
+  } : {});
+  var get = /*#__PURE__*/function () {
+    var _ref = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(url, what) {
+      var _t;
+      return slicedToArray._regenerator().w(function (_context) {
+        while (1) switch (_context.p = _context.n) {
+          case 0:
+            _context.p = 0;
+            _context.n = 1;
+            return getJson(fetchImpl, url, init);
+          case 1:
+            return _context.a(2, _context.v);
+          case 2:
+            _context.p = 2;
+            _t = _context.v;
+            throw sourceErrorOf(_t, what);
+          case 3:
+            return _context.a(2);
+        }
+      }, _callee, null, [[0, 2]]);
+    }));
+    return function get(_x4, _x5) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return {
+    types: function types(pkg) {
+      return slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee2() {
+        var what, query, answer, stubs;
+        return slicedToArray._regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              what = "The types of ".concat(pkg.name, "@").concat(pkg.version);
+              query = pkg.integrity ? "?integrity=".concat(encodeURIComponent(pkg.integrity)) : "";
+              _context2.n = 1;
+              return get("".concat(options.base, "/types/public/").concat(pkg.name, "@").concat(pkg.version).concat(query), what);
+            case 1:
+              answer = _context2.v;
+              if (!(!isRecord(answer) || !isTextFiles(answer["files"]))) {
+                _context2.n = 2;
+                break;
+              }
+              throw new acquireTypes.SourceError("".concat(what, ": adept answered without a bundle."), "unexpected-answer", false);
+            case 2:
+              stubs = answer["stubs"];
+              return _context2.a(2, {
+                files: answer["files"],
+                stubs: Array.isArray(stubs) ? stubs.filter(function (stub) {
+                  return typeof stub === "string";
+                }) : []
+              });
+          }
+        }, _callee2);
+      }))();
+    },
+    compiler: function compiler(version) {
+      return slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee3() {
+        var what, answer;
+        return slicedToArray._regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              what = "TypeScript ".concat(version);
+              _context3.n = 1;
+              return get("".concat(options.base, "/compiler/").concat(version), what);
+            case 1:
+              answer = _context3.v;
+              if (!(!isRecord(answer) || !isTextFiles(answer["files"]))) {
+                _context3.n = 2;
+                break;
+              }
+              throw new acquireTypes.SourceError("".concat(what, ": adept answered without the compiler's files."), "unexpected-answer", false);
+            case 2:
+              return _context3.a(2, {
+                version: typeof answer["version"] === "string" ? answer["version"] : version,
+                files: answer["files"]
+              });
+          }
+        }, _callee3);
+      }))();
+    }
+  };
+}
+
+/*
+ * The typecheck of a proposal whose dependencies are its own (valbuild/home
+ * `docs/adept.md`, decision 20): the site's code with the site's lockfile --
+ * the base -- and the proposal's code with its lockfile, each checked as it
+ * would be after `pnpm install`, in the browser. Only the errors the base
+ * does not have count, and content is told them: a proposal with dependencies
+ * of its own is not published until a typecheck of what it stages has none.
+ */
+
+/** At most this many of the new errors are sent; the count says how many. */
+var MAX_REPORTED_ERRORS = 200;
+
+/** What the typecheck is doing, as it says so. */
+
+/** A new type error as content keeps it: a file always, a position always. */
+
+/**
+ * The calls a proposal's typecheck makes: the Studio's through its origin,
+ * home's upgrade page to content directly. `T` is the report as content
+ * answers it.
+ */
+
+var LOCKFILE = "pnpm-lock.yaml";
+var WORKSPACE = "pnpm-workspace.yaml";
+
+/** A type error as content keeps it: a file always, a position always. */
+function reportedError(error) {
+  var _error$file, _error$line, _error$column;
+  return {
+    file: (_error$file = error.file) !== null && _error$file !== void 0 ? _error$file : "(".concat(error.tsconfig, ")"),
+    line: (_error$line = error.line) !== null && _error$line !== void 0 ? _error$line : 0,
+    column: (_error$column = error.column) !== null && _error$column !== void 0 ? _error$column : 0,
+    code: error.code,
+    message: error.message
+  };
+}
+function describe(progress) {
+  switch (progress.step) {
+    case "layout":
+      return "Laying out node_modules";
+    case "compiler":
+      return "Loading TypeScript ".concat(progress.version);
+    case "types":
+      return "Loading types (".concat(progress.fetched, ")");
+    case "check":
+      return "Checking ".concat(progress.tsconfig);
+  }
+}
+function runProposalTypecheck(_x) {
+  return _runProposalTypecheck.apply(this, arguments);
+}
+
+/** New errors by file, each file's in order: how the dialog lists them. */
+function _runProposalTypecheck() {
+  _runProposalTypecheck = slicedToArray._asyncToGenerator(/*#__PURE__*/slicedToArray._regenerator().m(function _callee(deps) {
+    var _deps$onStep, _yield$deps$siteSourc, _ref5, _recorded$LOCKFILE, _ref6, _recorded$WORKSPACE, _project$LOCKFILE, _project$WORKSPACE;
+    var read, inputs, site, recorded, baseLockfile, _deps$onStep2, packageJson, baseWorkspace, withoutLockfile, project, checkOne, base, next, errors, typecheck, _t, _t2, _t3;
+    return slicedToArray._regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          (_deps$onStep = deps.onStep) === null || _deps$onStep === void 0 || _deps$onStep.call(deps, {
+            step: "reading"
+          });
+          _context.n = 1;
+          return deps.client.files(deps.name);
+        case 1:
+          read = _context.v;
+          inputs = read.staged.inputs;
+          if (!(inputs === null)) {
+            _context.n = 2;
+            break;
+          }
+          return _context.a(2, {
+            status: "nothing-staged"
+          });
+        case 2:
+          _context.n = 3;
+          return deps.siteSource();
+        case 3:
+          _t2 = _yield$deps$siteSourc = _context.v;
+          _t = _t2 !== null;
+          if (!_t) {
+            _context.n = 4;
+            break;
+          }
+          _t = _yield$deps$siteSourc !== void 0;
+        case 4:
+          if (!_t) {
+            _context.n = 5;
+            break;
+          }
+          _t3 = _yield$deps$siteSourc;
+          _context.n = 6;
+          break;
+        case 5:
+          _t3 = {};
+        case 6:
+          site = _t3;
+          _context.n = 7;
+          return deps.siteDependencyFiles();
+        case 7:
+          recorded = _context.v;
+          baseLockfile = (_ref5 = (_recorded$LOCKFILE = recorded[LOCKFILE]) !== null && _recorded$LOCKFILE !== void 0 ? _recorded$LOCKFILE : site[LOCKFILE]) !== null && _ref5 !== void 0 ? _ref5 : null;
+          if (!(baseLockfile === null)) {
+            _context.n = 10;
+            break;
+          }
+          // A site made before proposals carried dependencies has no lockfile on
+          // record: the base is checked against one computed from its package.json,
+          // as `pnpm install` would make it.
+          packageJson = site["package.json"];
+          if (!(packageJson === undefined)) {
+            _context.n = 8;
+            break;
+          }
+          throw new Error("The site has no package.json, so there is nothing to check the proposal against.");
+        case 8:
+          (_deps$onStep2 = deps.onStep) === null || _deps$onStep2 === void 0 || _deps$onStep2.call(deps, {
+            step: "lockfile"
+          });
+          _context.n = 9;
+          return deps.computeLockfile(packageJson, deps.signal);
+        case 9:
+          baseLockfile = _context.v;
+        case 10:
+          baseWorkspace = (_ref6 = (_recorded$WORKSPACE = recorded[WORKSPACE]) !== null && _recorded$WORKSPACE !== void 0 ? _recorded$WORKSPACE : site[WORKSPACE]) !== null && _ref6 !== void 0 ? _ref6 : null;
+          withoutLockfile = function withoutLockfile(files) {
+            var out = createForOfIteratorHelper._objectSpread2({}, files);
+            delete out[LOCKFILE];
+            return out;
+          };
+          project = proposalProject.proposalProject(site, read.files);
+          checkOne = function checkOne(which, files, lockfile, workspace) {
+            return deps.check({
+              files: withoutLockfile(files),
+              lockfile: lockfile,
+              workspace: workspace
+            }, {
+              signal: deps.signal,
+              onProgress: function onProgress(progress) {
+                var _deps$onStep3;
+                return (_deps$onStep3 = deps.onStep) === null || _deps$onStep3 === void 0 ? void 0 : _deps$onStep3.call(deps, {
+                  step: "checking",
+                  which: which,
+                  detail: describe(progress)
+                });
+              }
+            });
+          }; // One after the other: the worker that loaded the compiler for the first
+          // reuses it for the second.
+          _context.n = 11;
+          return checkOne("site", site, baseLockfile, baseWorkspace);
+        case 11:
+          base = _context.v;
+          _context.n = 12;
+          return checkOne("proposal", project, (_project$LOCKFILE = project[LOCKFILE]) !== null && _project$LOCKFILE !== void 0 ? _project$LOCKFILE : baseLockfile, (_project$WORKSPACE = project[WORKSPACE]) !== null && _project$WORKSPACE !== void 0 ? _project$WORKSPACE : baseWorkspace);
+        case 12:
+          next = _context.v;
+          errors = newErrors(base.errors, next.errors).map(reportedError);
+          _context.n = 13;
+          return deps.client.reportTypecheck(deps.name, createForOfIteratorHelper._objectSpread2({
+            inputs: inputs,
+            newErrors: errors.slice(0, MAX_REPORTED_ERRORS)
+          }, errors.length > MAX_REPORTED_ERRORS ? {
+            count: errors.length
+          } : {}));
+        case 13:
+          typecheck = _context.v;
+          return _context.a(2, {
+            status: "checked",
+            inputs: inputs,
+            errors: errors,
+            typecheck: typecheck
+          });
+      }
+    }, _callee);
+  }));
+  return _runProposalTypecheck.apply(this, arguments);
+}
+function errorsByFile(errors) {
+  var files = new Map();
+  var _iterator = createForOfIteratorHelper._createForOfIteratorHelper(errors),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var error = _step.value;
+      var list = files.get(error.file);
+      if (!list) files.set(error.file, list = []);
+      list.push(error);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return slicedToArray._toConsumableArray(files).sort(function (_ref, _ref2) {
+    var _ref3 = slicedToArray._slicedToArray(_ref, 1),
+      a = _ref3[0];
+    var _ref4 = slicedToArray._slicedToArray(_ref2, 1),
+      b = _ref4[0];
+    return a.localeCompare(b);
+  });
+}
+
+exports.LockfileError = acquireTypes.LockfileError;
+exports.SourceError = acquireTypes.SourceError;
+exports.UnsupportedLayoutError = acquireTypes.UnsupportedLayoutError;
+exports.packageNameOf = acquireTypes.packageNameOf;
+exports.typesPackageOf = acquireTypes.typesPackageOf;
+exports.BUNDLED_TYPESCRIPT = BUNDLED_TYPESCRIPT;
+exports.CompilerError = CompilerError;
+exports.MAX_REPORTED_ERRORS = MAX_REPORTED_ERRORS;
+exports.PROJECT_ROOT = PROJECT_ROOT;
+exports.adeptSources = adeptSources;
+exports.chooseCompiler = chooseCompiler;
+exports.errorsByFile = errorsByFile;
+exports.layoutOf = layoutOf;
+exports.lockedPackages = lockedPackages;
+exports.newErrors = newErrors;
+exports.reportedError = reportedError;
+exports.runProposalTypecheck = runProposalTypecheck;
+exports.typecheckProject = typecheckProject;
+exports.typescriptVersion = typescriptVersion;