bend-lint 0.1.0 → 0.2.0

package/src/linter/defaults.json

@@ -0,0 +1 @@
+["language/decreasing_call","language/forward_reference","language/reused_binder","language/unneeded_plus","layout/canon_import_path","layout/case","layout/directive_order","layout/format","layout/imports","no_unused/imports","performance/append_in_loop","performance/bang_after_fork","performance/dead_accumulator","performance/deep_call_in_fork","performance/drop_in_bang","performance/eager_branch","performance/gpu_fit","performance/list_index_loop","performance/loop_invariant_call","performance/missed_fork","performance/repeated_call","performance/template_value_field","performance/unused_result"]

package/src/linter/directives.bend

@@ -1,9 +1,9 @@
 import Base
-import bend-lint-api@0.1.0.0/shared/lists.bend as Lists
-import bend-lint-api@0.1.0.0/shared/names.bend as Names
-import bend-lint-api@0.1.0.0/shared/strings.bend as Strings
+import bend-lint-api@0.2.0.0/shared/lists.bend as Lists
+import bend-lint-api@0.2.0.0/shared/names.bend as Names
+import bend-lint-api@0.2.0.0/shared/strings.bend as Strings
 import ../text/main.bend as Text
-import bend-lint-api@0.1.0.0/linter/lint.bend as Lint
+import bend-lint-api@0.2.0.0/linter/lint.bend as Lint
 
 # Scanning
 # ========

package/src/linter/fixes.bend

@@ -1,11 +1,12 @@
 # The fixes a run makes with `--fix-dangerously`: no fix is proven to keep the program until Bend's checker is Bend.
 import Base
 import ../files/main.bend as Files
-import bend-lint-api@0.1.0.0/shared/lists.bend as Lists
-import bend-lint-api@0.1.0.0/shared/names.bend as Names
-import bend-lint-api@0.1.0.0/shared/strings.bend as Strings
+import bend-lint-api@0.2.0.0/shared/lists.bend as Lists
+import bend-lint-api@0.2.0.0/shared/names.bend as Names
+import bend-lint-api@0.2.0.0/shared/sets.bend as Sets
+import bend-lint-api@0.2.0.0/shared/strings.bend as Strings
 import ../text/main.bend as Text
-import bend-lint-api@0.1.0.0/linter/lint.bend as Lint
+import bend-lint-api@0.2.0.0/linter/lint.bend as Lint
 
 # Types
 # =====
@@ -149,7 +150,7 @@ def Rename.is_allowed(
     case True{} True{} _:
       False{}
     case True{} False{} Some{Lint.Span{path, beg, end}}:
-      Bool.not(Pair.snd(Set(), Bool, Set.has(taken, Taken.key(path, alias, to))))
+      Bool.not(Sets.has(taken, Taken.key(path, alias, to)))
     case True{} False{} None{}:
       False{}
 
@@ -727,16 +728,80 @@ def write.done(path: String, written: Bool) -> IO(Unit):
     case False{}:
       IO.die(Unit, 2, "bend-lint: could not write " ++ path)
 
+# Check both prefixes because the pinned String.eq uses the JavaScript stack for each character.
+def write.read(
+  +path: String,
+  +text: String,
+  edits: List<&2, Text.Edit>,
+  read: File & Result<&1, &1, U32 & String, String>
+) -> IO(Unit):
+  match read:
+    case Tuple{file, Done{+current}}:
+      do IO<Unit>:
+        File.close(file)
+        Bool.pick(
+          IO(Unit),
+          Bool.and(String.starts_with(text, current), String.starts_with(current, text)),
+          IO.pure(Unit, Unit{}),
+          IO.die(
+            Unit,
+            2,
+            "bend-lint: " ++ path ++ ": file changed during lint; run the command again"
+          )
+        )
+        IO.bind(Bool, Unit, Files.write(path, Text.apply(edits, text)), w => write.done(path, w))
+    case Tuple{file, Fail{Tuple{code, why}}}:
+      do IO<Unit>:
+        File.close(file)
+        IO.die(Unit, 2, "bend-lint: could not read " ++ path ++ ": " ++ why)
+
+# Read one block to keep UTF-8 characters whole, with one extra byte to detect growth.
+def write.sized(
+  path: String,
+  text: String,
+  edits: List<&2, Text.Edit>,
+  sized: File & Result<&1, &1, U32 & String, U32>
+) -> IO(Unit):
+  match sized:
+    case Tuple{file, Done{+size}}:
+      IO.bind(
+        File & Result<&1, &1, U32 & String, String>,
+        Unit,
+        File.read(file, U32.max(size, (size + 1: U32))),
+        read => write.read(path, text, edits, read)
+      )
+    case Tuple{file, Fail{Tuple{code, why}}}:
+      do IO<Unit>:
+        File.close(file)
+        IO.die(Unit, 2, "bend-lint: could not read " ++ path ++ ": " ++ why)
+
+def write.opened(
+  path: String,
+  text: String,
+  edits: List<&2, Text.Edit>,
+  opened: Result<&1, &1, U32 & String, File>
+) -> IO(Unit):
+  match opened:
+    case Done{file}:
+      IO.bind(
+        File & Result<&1, &1, U32 & String, U32>,
+        Unit,
+        File.size(file),
+        sized => write.sized(path, text, edits, sized)
+      )
+    case Fail{Tuple{code, why}}:
+      IO.die(Unit, 2, "bend-lint: could not read " ++ path ++ ": " ++ why)
+
 def write.edited(+path: String, text: String, edits: List<&2, Text.Edit>) -> IO(Unit):
   match edits:
     case Nil{}:
       IO.pure(Unit, Unit{})
     case Con{e, rest}:
       IO.bind(
-        Bool,
+        Result<&1, &1, U32 & String, File>,
         Unit,
-        Files.write(path, Text.apply(Con{e, rest}, text)),
-        w => write.done(path, w)
+        File.open(path, "r"),
+        opened => write.opened(path, text, Con{e, rest}, opened)
       )
 
 def write.all(sources: List<&2, Lint.Source>, +groups: Map<&2, List<&2, Text.Edit>>) -> IO(Unit):

package/src/linter/seam.ts

@@ -223,13 +223,23 @@ export const BUILD = url.fileURLToPath(new URL("build/", import.meta.url));
 const CONFIG = "bend-lint.json";
 const RULES = "bend-lint-rules";
 
+// bend-lint's version, as its BendHub packages have it: with `.0` added.
+const HUB_VERSION = `${pkg.version}.0`;
+
 // The rule API, as rules import it from BendHub: src/linter/lint.bend and the files it imports, at
 // their paths from src/, in the package bend-lint-api, at bend-lint's version (see ship.ts).
-export const API = `bend-lint-api@${pkg.version}.0`;
+export const API = `bend-lint-api@${HUB_VERSION}`;
 
 // bend-lint's own rules, as projects get them from BendHub, at bend-lint's version: each at its
 // path from bend-lint-rules/ (see ship.ts).
-export const DEFAULTS = `bend-lint-rules@${pkg.version}.0`;
+const DEFAULTS_NAME = "bend-lint-rules";
+export const DEFAULTS = `${DEFAULTS_NAME}@${HUB_VERSION}`;
+
+// The ids of bend-lint's own rules in DEFAULTS, as the npm package lists them (see ship.ts); none
+// in this repo, which runs them from bend-lint-rules/.
+const DEFAULT_IDS = tryGetJson(url.fileURLToPath(new URL("defaults.json", import.meta.url))) as
+  | string[]
+  | undefined;
 
 // A path Bend imports: up, then names (letters, digits, _ and -).
 const PLAIN = /^(\.\.\/)*([A-Za-z_][\w-]*\/)*[A-Za-z_][\w-]*\.bend$/;
@@ -238,17 +248,20 @@ const PLAIN = /^(\.\.\/)*([A-Za-z_][\w-]*\/)*[A-Za-z_][\w-]*\.bend$/;
 const PER_PROJECT =
   "install bend-lint in this project (bun add -D bend-lint): Bend imports files only by relative paths of plain names, so bend-lint cannot reach your rules from elsewhere";
 
-// What `bend-lint init` writes: a config that turns on the formatter, and the formatter's rule,
-// which uses bend-lint's own.
-const INIT_CONFIG = `{\n  "rules": {\n    "format": "warning"\n  }\n}\n`;
-const INIT_FORMAT =
-  "# format: bend-lint's formatter (layout/format). Its options go in bend-lint.json; see\n" +
-  "# bend-lint's README.\n" +
-  "import Base\n" +
-  `import ${API}/linter/lint.bend as Lint\n` +
-  `import ${DEFAULTS}/layout/format.bend as Format\n\n` +
-  "def rule() -> Lint.Rule:\n" +
-  "  Format.rule()\n";
+// What a run that prepares says first (see `prepare`).
+const PREPARING =
+  "bend-lint: preparing Bend and the build of the rules; a build takes about a minute";
+
+// What `bend-lint init` writes: a config that turns on bend-lint's formatter.
+const INIT_CONFIG =
+  JSON.stringify(
+    {
+      packages: { [DEFAULTS_NAME]: HUB_VERSION },
+      rules: { [DEFAULTS_NAME + "/layout/format"]: "warning" },
+    },
+    null,
+    2,
+  ) + "\n";
 
 // An import by a relative path: of a .bend file, or, quoted, of an effect's.
 export const IMPORT = /^\s*import\s+"?(\.\.?\/[^\s"]+)/gm;
@@ -398,6 +411,14 @@ ${TRACED.map(
 // The text of each file bend.ts read while the check that runs read it, by the path it read.
 const READS = new Map<string, string>();
 
+// The texts that `--overlays` gives on stdin, by their files' keys (see `getOverlayKey`): a check
+// reads each in place of its file, which need not be on disk.
+const OVERLAYS = new Map<string, string>();
+
+// What a run's report counts (see `--report`): whether the run built its rules; its checks, from
+// the cache and not; and how long Bend's checker took.
+const COUNTS = { built: false, cached: 0, checked: 0, checkerMs: 0 };
+
 // How many syntax nodes the server made: the next one's number.
 const MADE = { nodes: 0 };
 
@@ -481,6 +502,24 @@ const getPatchedCopy = (dir: URL): URL => {
 const getRealPath = (p: nodeFs.PathLike): string =>
   getPathWithForwardSlashes(nodeFs.realpathSync(p));
 
+// The path of a file as Bend names it once it loads it: its folder's real path, with `/`, then its
+// name; or, if its folder is not on disk, its absolute path.
+const getOverlayKey = (p: string): string => {
+  const absolute = nodePath.resolve(p);
+  const folder = nodePath.dirname(absolute);
+  return (
+    (tryGet(() => getRealPath(folder)) ?? getPathWithForwardSlashes(folder)).replace(/\/$/, "") +
+    "/" +
+    nodePath.basename(absolute)
+  );
+};
+
+const getOverlay = (p: nodeFs.PathOrFileDescriptor): string | undefined =>
+  OVERLAYS.size === 0 || typeof p === "number" ? undefined : OVERLAYS.get(getOverlayKey(String(p)));
+
+// The text of the file at `p`, as the run sees it: its overlay, or what is on disk.
+const getViewText = (p: string): string => getOverlay(p) ?? nodeFs.readFileSync(p, "utf8");
+
 // path.posix.resolve, where a drive letter is a root.
 const getResolvedPosixPath = (...ps: string[]): string => {
   const all = [process.cwd(), ...ps].map(getPathWithForwardSlashes);
@@ -498,9 +537,10 @@ const getRelativePosixPath = (from: string, to: string): string =>
     getPathWithForwardSlashes(to).replace(DRIVE, ""),
   );
 
-// Node's readFileSync, which keeps in READS each text it reads.
+// Node's readFileSync, which reads a file's overlay in its place, and keeps in READS each text it
+// reads.
 const getKeptRead = ((p: nodeFs.PathOrFileDescriptor, options?: unknown) => {
-  const read = nodeFs.readFileSync(p, options as BufferEncoding);
+  const read = getOverlay(p) ?? nodeFs.readFileSync(p, options as BufferEncoding);
   if (typeof read === "string") {
     READS.set(String(p), read);
   }
@@ -508,10 +548,17 @@ const getKeptRead = ((p: nodeFs.PathOrFileDescriptor, options?: unknown) => {
 }) as typeof nodeFs.readFileSync;
 
 // What the server Shares with its copy of bend.ts: Node's fs and path, with each path they give
-// real and with `/`, as Bend resolves imports with path.posix, where a drive letter is a root; and
-// each text Bend reads kept.
+// real and with `/`, as Bend resolves imports with path.posix, where a drive letter is a root; each
+// text Bend reads kept; and each file with an overlay there, as its key.
 const getShared = (): Shared => ({
-  fs: { ...nodeFs, realpathSync: getRealPath, readFileSync: getKeptRead },
+  fs: {
+    ...nodeFs,
+    existsSync: (p: nodeFs.PathLike): boolean =>
+      getOverlay(String(p)) !== undefined || nodeFs.existsSync(p),
+    realpathSync: (p: nodeFs.PathLike): string =>
+      getOverlay(String(p)) === undefined ? getRealPath(p) : getOverlayKey(String(p)),
+    readFileSync: getKeptRead,
+  },
   path: {
     ...nodePath,
     join: (...ps: string[]): string => getPathWithForwardSlashes(nodePath.join(...ps)),
@@ -1462,9 +1509,12 @@ const getUntemplated = (x: unknown, bok: Book): unknown => {
   );
 };
 
-// The path Bend loads a file at, as `seen` keeps it: real, with `/`.
+// The path Bend loads a file at, as `seen` keeps it: real, with `/`; a file with an overlay, at its
+// key.
 const getLoadPath = (path: string): string =>
-  tryGet(() => getRealPath(path)) ?? getPathWithForwardSlashes(nodePath.resolve(path));
+  getOverlay(path) === undefined
+    ? (tryGet(() => getRealPath(path)) ?? getPathWithForwardSlashes(nodePath.resolve(path)))
+    : getOverlayKey(path);
 
 // Checks the file at `path`, as `check <path> <facts|syntax> <paths...>` asks. Its answer: `check`
 // and the check's number, here 0 (see `getNumberedAnswer`), or `failed` and each file it read;
@@ -1472,6 +1522,7 @@ const getLoadPath = (path: string): string =>
 // `getTreeRecords`). A passed check gives the facts of the files at `facts.paths` (all, if none).
 // The hooks are global, so checks must not overlap.
 const getCheck = async (checker: Checker, path: string, facts: Wanted): Promise<Made> => {
+  const start = performance.now();
   const { Bend, base } = await checker.getLoaded();
   const book = getSeededBook(Bend, base);
   const seen = new Map<string, string | null>([[Bend.BASE_BEND, ""]]);
@@ -1522,6 +1573,7 @@ const getCheck = async (checker: Checker, path: string, facts: Wanted): Promise<
     ),
   );
   const read = [...READS];
+  COUNTS.checkerMs += performance.now() - start;
   return passed
     ? { answer: [getRecord(["check", "0"]), ...program].join(""), read, held }
     : {
@@ -1600,12 +1652,12 @@ const getCachePath = ({ version }: Checker, path: string, facts: Wanted): string
     ) + ".json",
   );
 
-// The cached answer at `file`, if each file it read still has the text it read. A hit marks the
-// entry used now.
+// The cached answer at `file`, if each file it read still has the text it read (its overlay's, if
+// it has one). A hit marks the entry used now.
 const getCachedEntry = (file: string): Entry | undefined =>
   tryGet(() => {
     const entry = JSON.parse(nodeFs.readFileSync(file, "utf8")) as Entry;
-    if (!entry.files.every(([p, d]) => getSha256Hex(nodeFs.readFileSync(p, "utf8")) === d)) {
+    if (!entry.files.every(([p, d]) => getSha256Hex(getViewText(p)) === d)) {
       return undefined;
     }
     nodeFs.utimesSync(file, new Date(), new Date());
@@ -1702,6 +1754,7 @@ export const getBuiltProgram = async (source: string, dir: URL): Promise<string>
     }
     return exe;
   }
+  COUNTS.built = true;
   nodeFs.mkdirSync(PROGRAMS_DIR, { recursive: true });
   const part = nodeFs.mkdtempSync(nodePath.join(PROGRAMS_DIR, ".part-"));
   try {
@@ -1731,6 +1784,7 @@ export const getBuiltProgram = async (source: string, dir: URL): Promise<string>
 const getCheckAnswer = async (checker: Checker, path: string, facts: Wanted): Promise<string> => {
   const file = getCachePath(checker, path, facts);
   let entry = getCachedEntry(file);
+  COUNTS[entry === undefined ? "checked" : "cached"] += 1;
   if (entry === undefined) {
     const made = await getCheck(checker, path, facts);
     if (made.held === undefined) {
@@ -1891,6 +1945,56 @@ const getObjectEntries = (value: unknown): Array<[string, unknown]> | undefined
     ? Object.entries(value)
     : undefined;
 
+// Ends the run with status 2, as `message` says on stderr, about `file` if one; a JSON run first
+// prints the error on stdout, as the runner does (Error.json in cli.bend).
+const endWithError = (json: boolean, message: string, file?: string): never => {
+  const text = "bend-lint: " + message;
+  if (json) {
+    const about = file === undefined ? {} : { path: getPathWithForwardSlashes(file) };
+    console.log(JSON.stringify({ ok: false, errors: [{ ...about, message: text }] }));
+  }
+  console.error(text);
+  return process.exit(2);
+};
+
+// What `--report` writes as a run ends, for a bug report: the versions, the backend, the run's
+// build and caches, the times (in ms) of its setup, of Bend's checker and of the whole run, and its
+// exit code. No text of a source.
+const getReport = (
+  program: string,
+  notes: string[],
+  times: { setupMs: number; runMs: number },
+  code: number,
+): object => ({
+  bendLint: pkg.version,
+  notes,
+  runtime:
+    process.versions.bun === undefined ? "node " + process.version : "bun " + process.versions.bun,
+  platform: process.platform + " " + process.arch,
+  backend: program.endsWith(".js") ? "javascript" : "native",
+  program: getPathWithForwardSlashes(program),
+  cache: {
+    dir: getPathWithForwardSlashes(url.fileURLToPath(SERVER_CACHE_DIR)),
+    built: COUNTS.built,
+    checks: { cached: COUNTS.cached, checked: COUNTS.checked },
+  },
+  timings: {
+    setupMs: Math.round(times.setupMs),
+    checkerMs: Math.round(COUNTS.checkerMs),
+    runMs: Math.round(times.runMs),
+  },
+  exitCode: code,
+});
+
+// Keeps the overlays of `text`, which `--overlays` reads on stdin: a JSON object of paths to texts.
+const readOverlays = (text: string): void => {
+  const entries = getObjectEntries(tryGet(() => JSON.parse(text) as unknown));
+  if (entries === undefined || entries.some(([, t]) => typeof t !== "string")) {
+    throw new Error("--overlays reads a JSON object of paths to texts on stdin");
+  }
+  entries.forEach(([p, t]) => OVERLAYS.set(getOverlayKey(p), t as string));
+};
+
 // What the bend-lint.json in `project` says of its rules: those of "rules" but those "off", and
 // "packages". Bend checks the packages' names and versions; the runner, the rest of the config.
 export const getRules = (project: string): Rules => {
@@ -1962,13 +2066,28 @@ export const getRulesProgram = (project: string, { ids, packages }: Rules): stri
   return source;
 };
 
-// Makes bend-lint.json and bend-lint-rules/format.bend in `dir`, those that are not there; gives
-// those it wrote, and those it kept.
+// The rules a run of a config of `rules` builds: those it turns on; but if each is one of
+// bend-lint's own (DEFAULT_IDS) from DEFAULTS, all of bend-lint's own. That program is the same for
+// each such config, so one build serves them all, made once (see `prepare`): the runner runs only
+// the rules its config turns on.
+const getBuiltRules = (rules: Rules): Rules => {
+  const isDefault = (id: string): boolean =>
+    id.startsWith(DEFAULTS_NAME + "/") &&
+    (DEFAULT_IDS?.includes(id.slice(DEFAULTS_NAME.length + 1)) ?? false);
+  return DEFAULT_IDS !== undefined &&
+    rules.packages.get(DEFAULTS_NAME) === HUB_VERSION &&
+    rules.ids.every(isDefault)
+    ? { ids: DEFAULT_IDS.map((id) => DEFAULTS_NAME + "/" + id), packages: rules.packages }
+    : rules;
+};
+
+// The program of the rules a run in `project` builds.
+const getProjectProgram = (project: string): string =>
+  getRulesProgram(project, getBuiltRules(getRules(project)));
+
+// Makes bend-lint.json in `dir`, if it is not there; gives the files it wrote, and those it kept.
 const getInitFiles = (dir: string): { wrote: string[]; kept: string[] } => {
-  const files: Array<[string, string]> = [
-    [nodePath.join(dir, CONFIG), INIT_CONFIG],
-    [nodePath.join(dir, RULES, "format.bend"), INIT_FORMAT],
-  ];
+  const files: Array<[string, string]> = [[nodePath.join(dir, CONFIG), INIT_CONFIG]];
   const kept = files.filter(([file]) => nodeFs.existsSync(file)).map(([file]) => file);
   const wrote = files
     .filter(([file]) => !kept.includes(file))
@@ -2000,8 +2119,9 @@ if (import.meta.main) {
     }
     process.exit(0);
   }
-  // An install of bend-lint: the project that installs it in its node_modules gets what init
-  // makes, and bend-lint downloads its Bend now, not on its first run. It never fails the install.
+  // An install of bend-lint: bend-lint downloads its Bend now, not on its first run; and the project
+  // that installs it in its node_modules gets what init makes, and the build of its rules (see
+  // `prepare`). It never fails the install.
   if (args[0] === "postinstall") {
     try {
       const project = process.env.INIT_CWD ?? "";
@@ -2010,30 +2130,77 @@ if (import.meta.main) {
         modules === undefined
           ? ".."
           : nodePath.relative(modules, url.fileURLToPath(new URL("../../", import.meta.url)));
+      unwrap(await tryGetBend2SourceUrl());
       if (!relative.startsWith("..") && !nodePath.isAbsolute(relative)) {
         getInitFiles(project).wrote.forEach((file) => console.log("bend-lint: wrote " + file));
+        console.log(PREPARING);
+        await getRunSetup(getProjectProgram(project));
       }
-      unwrap(await tryGetBend2SourceUrl());
     } catch (e) {
       console.error("bend-lint: " + getErrorMessageFromUnknown(e) + "; its first run tries again");
     }
     process.exit(0);
   }
-  const project = getProject(process.cwd());
-  if (project === undefined) {
-    console.error(
-      "bend-lint: no " + CONFIG + " in this folder or above it; `bunx bend-lint init` makes one",
-    );
-    process.exit(2);
+  // The runner never sees `--overlays`: it gets the files that have one in BEND_LINT_OVERLAYS, and
+  // each argument that names one as its key.
+  const started = performance.now();
+  const json = args.includes("--json");
+  // `--report <file>` writes the run's report there (see `getReport`); the runner never sees it.
+  const reportAt = args.indexOf("--report");
+  const report = reportAt === -1 ? undefined : args[reportAt + 1];
+  if (reportAt !== -1 && (report === undefined || report.startsWith("--"))) {
+    endWithError(json, "--report names the file to write the report to");
+  }
+  if (args.includes("--overlays")) {
+    try {
+      readOverlays(nodeFs.readFileSync(0, "utf8"));
+    } catch (e) {
+      endWithError(json, getErrorMessageFromUnknown(e));
+    }
   }
+  const runArgs = args
+    .filter(
+      (a, n) => a !== "--overlays" && (reportAt === -1 || (n !== reportAt && n !== reportAt + 1)),
+    )
+    .map((a) => (getOverlay(a) === undefined ? a : getOverlayKey(a)));
+  const project =
+    getProject(process.cwd()) ??
+    endWithError(
+      json,
+      "no " + CONFIG + " in this folder or above it; `bunx bend-lint init` makes one",
+    );
 
-  const [checker, program, notes] = await Promise.resolve()
-    .then(() => getRunSetup(getRulesProgram(project, getRules(project))))
-    .catch((e: unknown) => {
-      console.error("bend-lint: " + getErrorMessageFromUnknown(e));
-      return process.exit(2);
-    });
+  // `bend-lint prepare` makes what a run needs, Bend and the build of its rules, and lints nothing:
+  // an editor runs it at start, so that its first check builds nothing.
+  const preparing = args[0] === "prepare";
+  if (preparing) {
+    console.error(PREPARING);
+  }
+  const named = await Promise.resolve()
+    .then(() => getProjectProgram(project))
+    .catch((e: unknown) =>
+      endWithError(json, getErrorMessageFromUnknown(e), nodePath.join(project, CONFIG)),
+    );
+  const [checker, program, notes] = await getRunSetup(named).catch((e: unknown) =>
+    endWithError(json, getErrorMessageFromUnknown(e)),
+  );
+  const setupMs = performance.now() - started;
   notes.forEach((note) => console.error(note));
+  // Writes the report, if the run asks for one, as it ends with `code`.
+  const writeReport = (code: number): void => {
+    if (report !== undefined) {
+      const times = { setupMs, runMs: performance.now() - started };
+      writeFileAtomically(
+        report,
+        JSON.stringify(getReport(program, notes, times, code), null, 2) + "\n",
+      );
+    }
+  };
+  if (preparing) {
+    console.error("bend-lint: prepared " + program);
+    writeReport(0);
+    process.exit(0);
+  }
 
   const inTurn = getSerialRunner();
   const server = net.createServer((socket) => void serve(checker, inTurn, socket));
@@ -2042,18 +2209,20 @@ if (import.meta.main) {
 
   // A JS build of the program runs on this runtime; a native one, as itself.
   const [command, commandArgs] = /\.m?js$/.test(program)
-    ? [process.execPath, [program, ...args]]
-    : [program, args];
+    ? [process.execPath, [program, ...runArgs]]
+    : [program, runArgs];
   const child = spawn(command, commandArgs, {
     env: {
       ...process.env,
       BEND_LINT_PORT: String((server.address() as net.AddressInfo).port),
       BEND_LINT_PROJECT: getPathWithForwardSlashes(project),
+      BEND_LINT_OVERLAYS: [...OVERLAYS.keys()].join("\n"),
     },
     stdio: "inherit",
   });
   const [code] = (await once(child, "exit")) as [number | null];
   server.close();
+  writeReport(code ?? 1);
   prune(CHECKS_DIR);
   prune(PROGRAMS_DIR);
   process.exit(code ?? 1);

package/src/shared/utils.ts

@@ -23,10 +23,12 @@ export const getCommandOutcome = async (
   cmd: string[],
   cwd: string,
   env: Record<string, string> = {},
+  input?: string,
 ): Promise<Outcome> => {
   const child = Bun.spawn(cmd, {
     cwd,
     env: { ...process.env, ...env },
+    stdin: input === undefined ? "ignore" : new TextEncoder().encode(input),
     stdout: "pipe",
     stderr: "pipe",
   });

package/src/text/main.bend

@@ -1,9 +1,9 @@
 # Edits to texts, and places in them: the edits to make, spans that must not touch, and the lines and columns of
 # offsets.
 import Base
-import bend-lint-api@0.1.0.0/shared/lists.bend as Lists
-import bend-lint-api@0.1.0.0/shared/names.bend as Names
-import bend-lint-api@0.1.0.0/shared/strings.bend as Strings
+import bend-lint-api@0.2.0.0/shared/lists.bend as Lists
+import bend-lint-api@0.2.0.0/shared/names.bend as Names
+import bend-lint-api@0.2.0.0/shared/strings.bend as Strings
 
 # Edits
 # =====