build-raptor 0.136.0 → 0.138.0

package/index.js

@@ -2,7 +2,8 @@ var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // modules/build-raptor-core/dist/src/breakdown.js
-import * as fse5 from "fs-extra";
+import fs5 from "fs";
+import fse5 from "fs-extra/esm";
 
 // modules/misc/dist/src/maps.js
 function hardGet(map, key) {
@@ -121,13 +122,14 @@ function errorLike(err) {
 __name(errorLike, "errorLike");
 
 // modules/misc/dist/src/directory-scanner.js
-import * as fs from "fs";
-import * as fse2 from "fs-extra";
+import * as fs2 from "fs";
+import fse2 from "fs-extra/esm";
 import * as path from "path";
 
 // modules/misc/dist/src/misc.js
 import * as crypto from "crypto";
-import * as fse from "fs-extra";
+import fs from "fs";
+import fse from "fs-extra/esm";
 import jsonStringify from "safe-stable-stringify";
 import * as util from "util";
 function computeObjectHash(input) {
@@ -144,7 +146,7 @@ async function dumpFile(inputPath, output) {
     throw new Error(`Cannot dump non existing file: ${inputPath}`);
   }
   return new Promise((res, rej) => {
-    const inputStream = fse.createReadStream(inputPath);
+    const inputStream = fs.createReadStream(inputPath);
     inputStream.on("end", () => {
       res();
     });
@@ -278,9 +280,9 @@ var DirectoryScanner = class _DirectoryScanner {
   readContent(resolvedPath, stat) {
     try {
       if (stat.isSymbolicLink()) {
-        return Buffer.from(fs.readlinkSync(resolvedPath));
+        return Buffer.from(fs2.readlinkSync(resolvedPath));
       }
-      return fs.readFileSync(resolvedPath);
+      return fs2.readFileSync(resolvedPath);
     } catch (e) {
       throw new Error(`failed to read ${stat.isSymbolicLink() ? "symbolic link" : "file"} at ${resolvedPath}: ${e}`);
     }
@@ -292,7 +294,7 @@ var DirectoryScanner = class _DirectoryScanner {
   // does the sorting).
   async readDirSorted(resolvedPath) {
     try {
-      const ret = await fse2.readdir(resolvedPath);
+      const ret = await fs2.promises.readdir(resolvedPath);
       ret.sort();
       return ret;
     } catch (e) {
@@ -301,7 +303,7 @@ var DirectoryScanner = class _DirectoryScanner {
   }
   async getStat(resolvedPath) {
     try {
-      return fs.lstatSync(resolvedPath);
+      return fs2.lstatSync(resolvedPath);
     } catch (e) {
       throw new Error(`Cannot stat ${resolvedPath}: ${e}`);
     }
@@ -321,8 +323,8 @@ var SinglePublisher = class {
     this.subscribers.push(subscriber);
   }
   async publish(e) {
-    const promises3 = this.subscribers.map((s) => s(e));
-    await Promise.all(promises3);
+    const promises6 = this.subscribers.map((s) => s(e));
+    await Promise.all(promises6);
   }
 };
 var TypedPublisher = class {
@@ -418,11 +420,12 @@ var Executor = class {
 };
 
 // modules/misc/dist/src/file-system-storage-client.js
-import * as fse3 from "fs-extra";
+import fs4 from "fs";
+import fse3 from "fs-extra/esm";
 import * as path3 from "path";
 
 // modules/misc/dist/src/clean-directory.js
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path2 from "path";
 function cleanDirectory(directoryPath, deletionFactor, triggerCleanupIfByteSizeExceeds) {
   const size = calculateDirectorySize(directoryPath);
@@ -435,9 +438,9 @@ function cleanDirectory(directoryPath, deletionFactor, triggerCleanupIfByteSizeE
 __name(cleanDirectory, "cleanDirectory");
 function calculateDirectorySize(directoryPath) {
   let ret = 0;
-  for (const f of fs2.readdirSync(directoryPath)) {
+  for (const f of fs3.readdirSync(directoryPath)) {
     const resolved = path2.join(directoryPath, f);
-    const stats = fs2.statSync(resolved);
+    const stats = fs3.statSync(resolved);
     ret += stats.size;
   }
   return ret;
@@ -446,18 +449,18 @@ __name(calculateDirectorySize, "calculateDirectorySize");
 function deleteFiles(directoryPath, deletionFactor) {
   let files;
   try {
-    files = fs2.readdirSync(directoryPath);
+    files = fs3.readdirSync(directoryPath);
   } catch (e) {
     throw new Error(`failed when reading ${directoryPath}: ${e}`);
   }
-  const mapped = files.map((f) => ({ f, atime: fs2.statSync(path2.join(directoryPath, f)).atime.toISOString() }));
+  const mapped = files.map((f) => ({ f, atime: fs3.statSync(path2.join(directoryPath, f)).atime.toISOString() }));
   const sorted = sortBy(mapped, (at) => at.atime);
   const numFilesToDelete = Math.min(sorted.length, Math.floor(sorted.length * deletionFactor));
   const ret = sorted.slice(0, numFilesToDelete).map((at) => at.f);
   for (const f of ret) {
     const filePath = path2.join(directoryPath, f);
     try {
-      fs2.unlinkSync(filePath);
+      fs3.unlinkSync(filePath);
     } catch (e) {
       throw new Error(`cleanup of ${filePath} failed: ${e}`);
     }
@@ -489,26 +492,26 @@ var FilesystemStorageClient = class _FilesystemStorageClient {
     return path3.join(this.dir, `${middle}-${s}`);
   }
   async putObject(key, content) {
-    await fse3.writeFile(this.keyToPath(key), content);
+    await fs4.promises.writeFile(this.keyToPath(key), content);
   }
   async putContentAddressable(content) {
     const ret = computeHash(content);
     const p = this.hashToPath("cas", ret);
-    await fse3.writeFile(p, content);
+    await fs4.promises.writeFile(p, content);
     return ret;
   }
   async getContentAddressable(hash) {
     const p = this.hashToPath("cas", hash);
-    return await fse3.readFile(p);
+    return await fs4.promises.readFile(p);
   }
   async getObject(key, type = "string") {
     const p = this.keyToPath(key);
     try {
       if (type === "string") {
-        return await fse3.readFile(p, "utf-8");
+        return await fs4.promises.readFile(p, "utf-8");
       }
       if (type === "buffer") {
-        return await fse3.readFile(p);
+        return await fs4.promises.readFile(p);
       }
       shouldNeverHappen(type);
     } catch (e) {
@@ -521,7 +524,7 @@ var FilesystemStorageClient = class _FilesystemStorageClient {
 };
 
 // modules/misc/dist/src/folderify.js
-import * as fse4 from "fs-extra";
+import fse4 from "fs-extra/esm";
 import * as Tmp from "tmp-promise";
 
 // modules/misc/dist/src/graph.js
@@ -865,11 +868,11 @@ __name(intify, "intify");
 
 // modules/misc/dist/src/promises.js
 import PQueue2 from "p-queue";
-function promises(input) {
+function promises2(input) {
   const adjusted = new DefaultReifiable(input.map((p) => Promise.resolve(p)));
   return new PromisesImpl(adjusted, (t) => Promise.resolve(t), () => Promise.resolve(true));
 }
-__name(promises, "promises");
+__name(promises2, "promises");
 var PromisesImpl = class _PromisesImpl {
   static {
     __name(this, "PromisesImpl");
@@ -1125,7 +1128,7 @@ var Breakdown = class {
       if (!outputFile) {
         return [];
       }
-      const content = await fse5.readFile(outputFile, "utf8");
+      const content = await fs5.promises.readFile(outputFile, "utf8");
       const trimmed = content.trim();
       return format3 === "string" ? trimmed : trimmed.split("\n");
     }
@@ -1142,7 +1145,7 @@ var Breakdown = class {
     if (!await fse5.pathExists(resolved)) {
       return void 0;
     }
-    const content = await fse5.readFile(resolved, "utf8");
+    const content = await fs5.promises.readFile(resolved, "utf8");
     return content.trim().split("\n");
   }
 };
@@ -1199,11 +1202,11 @@ function BuildRunId(input) {
 __name(BuildRunId, "BuildRunId");
 
 // modules/build-raptor-core/dist/src/engine-bootstrapper.js
-import * as fs9 from "fs";
+import * as fs14 from "fs";
 import * as JsoncParser from "jsonc-parser";
 
 // modules/logger/dist/src/logger.js
-import * as fs3 from "fs";
+import * as fs6 from "fs";
 import { format } from "logform";
 import * as path6 from "path";
 import jsonStringify2 from "safe-stable-stringify";
@@ -1214,9 +1217,9 @@ var criticalityLegend = {
   low: 200
 };
 function createDefaultLogger(logFile, pickiness, logLevel, uiStream) {
-  const stat = fs3.statSync(logFile, { throwIfNoEntry: false });
+  const stat = fs6.statSync(logFile, { throwIfNoEntry: false });
   if (stat && stat.size > 0) {
-    fs3.rmSync(logFile, { force: true });
+    fs6.rmSync(logFile, { force: true });
   }
   return new FileLogger(logFile, pickiness, logLevel, uiStream);
 }
@@ -1309,13 +1312,13 @@ import { z as z7 } from "zod";
 
 // modules/build-raptor-core/dist/src/engine.js
 import child_process from "child_process";
-import * as fs5 from "fs";
-import * as fse10 from "fs-extra";
+import * as fs10 from "fs";
+import fse8 from "fs-extra/esm";
 import ignore from "ignore";
 import * as path10 from "path";
 
 // modules/build-raptor-core/dist/src/fingerprint-ledger.js
-import * as fse6 from "fs-extra";
+import fse6 from "fs-extra/esm";
 import { z as z2 } from "zod";
 var LedgerItem = z2.union([
   z2.object({
@@ -1444,8 +1447,7 @@ var PersistedFingerprintLedger = class {
 var TRUNCATION_THRESHOLD = 200 * 1e3 * 1e3;
 
 // modules/build-raptor-core/dist/src/fingerprinter.js
-import * as fs4 from "fs";
-import * as fse7 from "fs-extra";
+import * as fs7 from "fs";
 import * as path7 from "path";
 
 // modules/build-raptor-core/dist/src/hasher.js
@@ -1549,7 +1551,7 @@ var Fingerprinter = class {
     const respectGitIgnore = this.dirScanner.isValid(pathInRepo, stat);
     const active = this.dirScanner.isValid(pathInRepo, stat);
     if (!stat.isDirectory()) {
-      const content = await readFile4(resolved);
+      const content = await readFile(resolved);
       const hasher2 = new Hasher(pathInRepo, this.seed);
       hasher2.update(content);
       return await this.store(hasher2, active, content.toString("utf-8"));
@@ -1577,17 +1579,17 @@ var Fingerprinter = class {
     return { hasher, active };
   }
 };
-async function readFile4(p) {
+async function readFile(p) {
   try {
-    return await fse7.readFile(p);
+    return await fs7.promises.readFile(p);
   } catch (e) {
     throw new Error(`Failed to read ${p}: ${e}`);
   }
 }
-__name(readFile4, "readFile");
+__name(readFile, "readFile");
 function statPath(p) {
   try {
-    return fs4.statSync(p, { throwIfNoEntry: false });
+    return fs7.statSync(p, { throwIfNoEntry: false });
   } catch (e) {
     throw new Error(`Failed to stat ${p}: ${e}`);
   }
@@ -1595,7 +1597,7 @@ function statPath(p) {
 __name(statPath, "statPath");
 async function readDir(p) {
   try {
-    return await fse7.readdir(p, { withFileTypes: true });
+    return await fs7.promises.readdir(p, { withFileTypes: true });
   } catch (e) {
     throw new Error(`Failed to read dir ${p}: ${e}`);
   }
@@ -1926,7 +1928,7 @@ var Planner = class {
 };
 
 // modules/build-raptor-core/dist/src/purger.js
-import * as fse8 from "fs-extra";
+import fs8 from "fs";
 var Purger = class {
   static {
     __name(this, "Purger");
@@ -1936,10 +1938,10 @@ var Purger = class {
     this.repoRootDir = repoRootDir;
   }
   async removeLocations(outputLocations) {
-    await promises(outputLocations).forEach(20, async (p) => {
+    await promises2(outputLocations).forEach(20, async (p) => {
       const resolved = this.repoRootDir.resolve(p);
       this.logger.info(`purging ${resolved}`);
-      await fse8.rm(resolved, { recursive: true, force: true });
+      await fs8.promises.rm(resolved, { recursive: true, force: true });
     });
   }
   async purgeOutputsOfTask(task) {
@@ -1958,7 +1960,8 @@ function shouldPurge(loc) {
 __name(shouldPurge, "shouldPurge");
 
 // modules/build-raptor-core/dist/src/task-executor.js
-import * as fse9 from "fs-extra";
+import fs9 from "fs";
+import fse7 from "fs-extra/esm";
 import * as path9 from "path";
 var TaskExecutor = class {
   static {
@@ -2036,7 +2039,7 @@ var SingleTaskExecutor = class {
   }
   async postProcess(status, outputFile, time) {
     if (this.shouldDiagnose) {
-      const content = fse9.readFileSync(outputFile, "utf-8");
+      const content = fs9.readFileSync(outputFile, "utf-8");
       this.diagnose(`content of ${outputFile} is ${content}`);
     }
     await this.eventPublisher.publish("executionEnded", {
@@ -2069,9 +2072,9 @@ var SingleTaskExecutor = class {
   }
   async validateOutputs() {
     const t = this.task;
-    const missing = await promises(t.outputLocations).filter(async (loc) => {
+    const missing = await promises2(t.outputLocations).filter(async (loc) => {
       const resolved = this.model.rootDir.resolve(loc.pathInRepo);
-      const exists = await fse9.pathExists(resolved);
+      const exists = await fse7.pathExists(resolved);
       return !exists;
     }).reify(100);
     if (!missing.length) {
@@ -2226,7 +2229,7 @@ ${formatted}`);
     this.diagnose(`purging outputs`);
     const taskNames = [this.taskName];
     const tasks = taskNames.map((tn) => this.tracker.getTask(tn));
-    await promises(tasks).forEach(20, async (task) => {
+    await promises2(tasks).forEach(20, async (task) => {
       await this.purger.purgeOutputsOfTask(task);
     });
   }
@@ -2427,7 +2430,7 @@ var Engine = class {
   }
   async run(buildRunId) {
     this.steps.transmit({ step: "BUILD_RUN_STARTED", buildRunId, commitHash: this.options.commitHash });
-    fs5.writeFileSync(path10.join(this.options.buildRaptorDir, "build-run-id"), buildRunId);
+    fs10.writeFileSync(path10.join(this.options.buildRaptorDir, "build-run-id"), buildRunId);
     await this.fingerprintLedger.updateRun(buildRunId);
     await this.repoProtocol.initialize(this.rootDir, this.eventPublisher, this.options.config.outDirName, this.options.config.repoProtocol);
     try {
@@ -2515,8 +2518,8 @@ ${JSON.stringify(taskList, null, 2)}`);
   async loadModel(buildRunId) {
     const gitIgnorePath = this.rootDir.resolve(PathInRepo(".gitignore"));
     const ig = ignore();
-    if (await fse10.pathExists(gitIgnorePath)) {
-      const gitIgnoreContent = await fse10.readFile(gitIgnorePath, "utf8");
+    if (await fse8.pathExists(gitIgnorePath)) {
+      const gitIgnoreContent = await fs10.promises.readFile(gitIgnorePath, "utf8");
       const lines = gitIgnoreContent.split("\n");
       this.logger.info(`Found a .gitignore file:
 ${JSON.stringify(lines, null, 2)}`);
@@ -2864,7 +2867,7 @@ var Step = z4.discriminatedUnion("step", [
 var StepByStep = Step.array();
 
 // modules/build-raptor-core/dist/src/step-by-step-transmitter.js
-import * as fs6 from "fs";
+import * as fs11 from "fs";
 import * as util2 from "util";
 var StepByStepTransmitter = class {
   static {
@@ -2896,7 +2899,7 @@ var StepByStepTransmitter = class {
       return;
     }
     const parsed = StepByStep.parse(this.steps);
-    fs6.writeFileSync(this.stepByStepFile, JSON.stringify(parsed));
+    fs11.writeFileSync(this.stepByStepFile, JSON.stringify(parsed));
     this.logger.info(`step by step written to ${this.stepByStepFile}`);
   }
   async dynamicallyLoadProcessor(stepByStepProcessorModuleName, lookFor = "processor") {
@@ -2912,9 +2915,9 @@ var StepByStepTransmitter = class {
 };
 
 // modules/build-raptor-core/dist/src/task-store.js
-import * as fs8 from "fs";
+import * as fs13 from "fs";
 import { createWriteStream } from "fs";
-import * as fse11 from "fs-extra";
+import fse9 from "fs-extra/esm";
 import * as path12 from "path";
 import * as stream from "stream";
 import * as Tmp2 from "tmp-promise";
@@ -2923,7 +2926,7 @@ import * as zlib from "zlib";
 import { z as z6 } from "zod";
 
 // modules/build-raptor-core/dist/src/tar-stream.js
-import * as fs7 from "fs";
+import * as fs12 from "fs";
 import * as path11 from "path";
 import { z as z5 } from "zod";
 var Info = z5.object({
@@ -3030,7 +3033,7 @@ var TarStream = class _TarStream {
       const resolved = resolve2(parsedInfo);
       const date = new Date(Number(parsedInfo.mtime));
       try {
-        fs7.utimesSync(resolved, date, date);
+        fs12.utimesSync(resolved, date, date);
       } catch (e) {
         logger.error(`utimeSync failure: ${JSON.stringify({ resolved, date, parsedInfo })}`, e);
         throw new Error(`could not update time of ${resolved} to ${date.toISOString()}: ${e}`);
@@ -3059,19 +3062,19 @@ var TarStream = class _TarStream {
       source.copy(contentBuf, 0, offset, contentEndOffset);
       offset = contentEndOffset;
       const resolved = resolve2(parsedInfo);
-      fs7.mkdirSync(path11.dirname(resolved), { recursive: true });
+      fs12.mkdirSync(path11.dirname(resolved), { recursive: true });
       if (parsedInfo.isSymlink) {
         symlinks.push({ info: parsedInfo, content: contentBuf });
       } else {
-        fs7.writeFileSync(resolved, contentBuf, { mode: parsedInfo.mode });
+        fs12.writeFileSync(resolved, contentBuf, { mode: parsedInfo.mode });
         updateStats(parsedInfo);
       }
     }
     for (const { info, content } of symlinks) {
       const resolved = resolve2(info);
-      fs7.mkdirSync(path11.dirname(resolved), { recursive: true });
+      fs12.mkdirSync(path11.dirname(resolved), { recursive: true });
       const linkTarget = content.toString("utf-8");
-      fs7.symlinkSync(linkTarget, resolved);
+      fs12.symlinkSync(linkTarget, resolved);
       if (!path11.isAbsolute(linkTarget)) {
         updateStats(info);
       }
@@ -3173,13 +3176,13 @@ var TaskStore = class {
       return { buffer: emptyBuffer(), publicFiles: {} };
     }
     this.trace?.push(`bundling ${JSON.stringify(outputs)}`);
-    const pairs = await promises(outputs.filter((o) => o.isPublic)).map(async (o) => {
+    const pairs = await promises2(outputs.filter((o) => o.isPublic)).map(async (o) => {
       const resolved = this.repoRootDir.resolve(o.pathInRepo);
-      const stat = fs8.statSync(resolved);
+      const stat = fs13.statSync(resolved);
       if (!stat.isFile()) {
         throw new BuildFailedError(`cannot publish an output location that is not a file: "${o.pathInRepo.val}"`);
       }
-      const content = fs8.readFileSync(resolved);
+      const content = fs13.readFileSync(resolved);
       const h = await this.client.putContentAddressable(content);
       return [o.pathInRepo.val, h];
     }).reify(STORAGE_CONCURRENCY);
@@ -3195,7 +3198,7 @@ var TaskStore = class {
     const scanner = new DirectoryScanner(this.repoRootDir.resolve());
     for (const curr of outputs.filter((o) => !o.isPublic)) {
       const o = curr.pathInRepo;
-      const exists = await fse11.pathExists(this.repoRootDir.resolve(o));
+      const exists = await fse9.pathExists(this.repoRootDir.resolve(o));
       if (!exists) {
         throw new Error(`Output location <${o}> does not exist (under <${this.repoRootDir}>)`);
       }
@@ -3207,7 +3210,7 @@ var TaskStore = class {
           throw new Error(`Cannot handle non-files in output: ${p} (under ${this.repoRootDir})`);
         }
         const resolved = this.repoRootDir.resolve(PathInRepo(p));
-        const { mtime, atime, ctime } = fs8.statSync(resolved);
+        const { mtime, atime, ctime } = fs13.statSync(resolved);
         this.trace?.push(`adding an entry: ${stat.mode.toString(8)} ${p} ${mtime.toISOString()}`);
         if (stat.isSymbolicLink()) {
           const linkTarget = content.toString("utf-8");
@@ -3225,7 +3228,7 @@ var TaskStore = class {
     const gzip = zlib.createGzip();
     const destination = createWriteStream(tempFile.path);
     await pipeline2(source, gzip, destination);
-    const gzipped = await fse11.readFile(tempFile.path);
+    const gzipped = await fs13.promises.readFile(tempFile.path);
     this.trace?.push(`gzipped is ${gzipped.length} long`);
     const ret = Buffer.concat([lenBuf, metadataBuf, gzipped]);
     this.trace?.push(`bundling digest of ret is ${computeObjectHash({ data: ret.toString("hex") })}`);
@@ -3239,8 +3242,8 @@ var TaskStore = class {
     const unparsed = JSON.parse(buf.slice(LEN_BUF_SIZE, LEN_BUF_SIZE + metadataLen).toString("utf-8"));
     const metadata = Metadata.parse(unparsed);
     const outputs = metadata.outputs.map((at) => PathInRepo(at));
-    const removeOutputDir = /* @__PURE__ */ __name(async (o) => await fse11.rm(this.repoRootDir.resolve(o), { recursive: true, force: true }), "removeOutputDir");
-    await promises(outputs).map(async (o) => await removeOutputDir(o)).reify(20);
+    const removeOutputDir = /* @__PURE__ */ __name(async (o) => await fs13.promises.rm(this.repoRootDir.resolve(o), { recursive: true, force: true }), "removeOutputDir");
+    await promises2(outputs).map(async (o) => await removeOutputDir(o)).reify(20);
     const source = buf.slice(LEN_BUF_SIZE + metadataLen);
     const unzipped = await unzip2(source);
     try {
@@ -3248,7 +3251,7 @@ var TaskStore = class {
     } catch (e) {
       throw new Error(`unbundling a buffer (${buf.length} bytes) has failed: ${e}`);
     }
-    await promises(Object.keys(metadata.publicFiles)).forEach(STORAGE_CONCURRENCY, async (pir) => {
+    await promises2(Object.keys(metadata.publicFiles)).forEach(STORAGE_CONCURRENCY, async (pir) => {
       const pathInRepo = PathInRepo(pir);
       const resolved = this.repoRootDir.resolve(pathInRepo);
       const hash = metadata.publicFiles[pathInRepo.val];
@@ -3256,7 +3259,7 @@ var TaskStore = class {
         throw new Error(`hash not found for "${pathInRepo}"`);
       }
       const buf2 = await this.client.getContentAddressable(hash);
-      fs8.writeFileSync(resolved, buf2);
+      fs13.writeFileSync(resolved, buf2);
     });
     return { files: outputs, publicFiles: metadata.publicFiles };
   }
@@ -3356,7 +3359,7 @@ var EngineBootstrapper = class _EngineBootstrapper {
   }
   resolveConfigFile() {
     const arr = _EngineBootstrapper.CONFIG_FILES.map((at) => PathInRepo(at));
-    const existings = arr.flatMap((at) => fs9.existsSync(this.rootDir.resolve(at)) ? [at] : []);
+    const existings = arr.flatMap((at) => fs14.existsSync(this.rootDir.resolve(at)) ? [at] : []);
     if (existings.length > 1) {
       const quoted = existings.map((at) => `"${at}"`);
       throw new Error(`Found competing config files: ${quoted.join(", ")}. To avoid confusion, you must keep just one.`);
@@ -3369,10 +3372,10 @@ var EngineBootstrapper = class _EngineBootstrapper {
     }
     const p = this.rootDir.resolve(pathToConfigFile);
     try {
-      if (!fs9.existsSync(p)) {
+      if (!fs14.existsSync(p)) {
         return BuildRaptorConfig.parse({});
       }
-      const content = fs9.readFileSync(p, "utf-8");
+      const content = fs14.readFileSync(p, "utf-8");
       const errors = [];
       const parsed = JsoncParser.parse(content, errors, { allowTrailingComma: true, allowEmptyContent: true });
       const e = errors.at(0);
@@ -3467,14 +3470,14 @@ function summarizeTask(t) {
 __name(summarizeTask, "summarizeTask");
 
 // modules/build-raptor-core/dist/src/find-repo-dir.js
-import fs10 from "fs";
+import fs15 from "fs";
 import path14 from "path";
 function findRepoDir(dir3) {
   while (true) {
     const pj = path14.join(dir3, "package.json");
-    const ex = fs10.existsSync(pj);
+    const ex = fs15.existsSync(pj);
     if (ex) {
-      const content = JSON.parse(fs10.readFileSync(pj, "utf-8"));
+      const content = JSON.parse(fs15.readFileSync(pj, "utf-8"));
       const keys = Object.keys(content);
       if (keys.includes("workspaces")) {
         return dir3;
@@ -3490,8 +3493,8 @@ function findRepoDir(dir3) {
 __name(findRepoDir, "findRepoDir");
 
 // modules/build-raptor/dist/src/build-raptor-cli.js
-import fs12 from "fs";
-import * as fse13 from "fs-extra";
+import fs17 from "fs";
+import fse11 from "fs-extra/esm";
 import * as os from "os";
 import * as path16 from "path";
 
@@ -3641,8 +3644,8 @@ import { hideBin } from "yargs/helpers";
 // modules/yarn-repo-protocol/dist/src/yarn-repo-protocol.js
 import escapeStringRegexp from "escape-string-regexp";
 import execa from "execa";
-import * as fs11 from "fs";
-import * as fse12 from "fs-extra";
+import fs16 from "fs";
+import fse10 from "fs-extra/esm";
 import * as path15 from "path";
 
 // modules/reporter-output/dist/src/reporter-output.js
@@ -3863,23 +3866,23 @@ ${formattedIssues.join("\n")}`);
   async generateSymlinksToPackages(rootDir, units) {
     const nodeModules = PathInRepo("node_modules");
     const nodeModulesLoc = rootDir.resolve(nodeModules);
-    await fse12.mkdirp(rootDir.resolve(nodeModules));
+    await fse10.mkdirp(rootDir.resolve(nodeModules));
     for (const u of units) {
       const link = nodeModules.expand(u.id);
       const linkLoc = rootDir.resolve(link);
-      const exists = await fse12.pathExists(linkLoc);
+      const exists = await fse10.pathExists(linkLoc);
       if (exists) {
         continue;
       }
       const packageLoc = rootDir.resolve(u.pathInRepo);
       const packageFromNodeModules = path15.relative(nodeModulesLoc, packageLoc);
-      await fse12.symlink(packageFromNodeModules, linkLoc);
+      await fs16.promises.symlink(packageFromNodeModules, linkLoc);
     }
   }
   async generateTsConfigFiles(rootDir, units, graph) {
     const rootBase = rootDir.resolve(PathInRepo(this.tsconfigBaseName));
-    const rootBaseExists = await fse12.pathExists(rootBase);
-    const rootBaseContent = rootBaseExists ? await fse12.readJSON(rootBase) : {};
+    const rootBaseExists = await fse10.pathExists(rootBase);
+    const rootBaseContent = rootBaseExists ? await fse10.readJSON(rootBase) : {};
     const defaultOptions = {
       module: "CommonJS",
       inlineSourceMap: true,
@@ -3897,8 +3900,8 @@ ${formattedIssues.join("\n")}`);
     for (const u of units) {
       const deps = graph.neighborsOf(u.id);
       const localBase = rootDir.resolve(u.pathInRepo.expand(this.tsconfigBaseName));
-      const localBaseExists = await fse12.pathExists(localBase);
-      const localBaseContent = localBaseExists ? await fse12.readJSON(localBase) : {};
+      const localBaseExists = await fse10.pathExists(localBase);
+      const localBaseContent = localBaseExists ? await fse10.readJSON(localBase) : {};
       const additions = [...localBaseContent.include ?? [], ...rootBaseContent.include ?? []];
       const tsconf = {
         ...localBaseExists ? { extends: `./${this.tsconfigBaseName}` } : rootBaseExists ? { extends: path15.relative(u.pathInRepo.val, this.tsconfigBaseName) } : {},
@@ -3926,15 +3929,15 @@ ${formattedIssues.join("\n")}`);
       }
       const content = JSON.stringify(tsconf, null, 2);
       const p = rootDir.resolve(u.pathInRepo.expand("tsconfig.json"));
-      if (await fse12.pathExists(p)) {
-        const existing = JSON.stringify(await fse12.readJSON(p, "utf-8"), null, 2);
+      if (await fse10.pathExists(p)) {
+        const existing = JSON.stringify(await fse10.readJSON(p, "utf-8"), null, 2);
         if (existing.trim() === content.trim()) {
           this.logger.info(`skipping generation of tsconfig.json in ${u.id} - no changes`);
           continue;
         }
       }
       this.logger.info(`updating the tsconfig.json file of ${u.id}`);
-      await fse12.writeFile(p, content);
+      await fs16.promises.writeFile(p, content);
     }
   }
   async close() {
@@ -3942,9 +3945,15 @@ ${formattedIssues.join("\n")}`);
   async run(cmd, args, dir3, outputFile, additionalEnvVars = {}) {
     const summary = `<${dir3}$ ${cmd} ${args.join(" ")}>`;
     this.logger.info(`Dispatching ${summary}. output: ${outputFile}`);
-    const out = await fse12.open(outputFile, "w");
+    const out = await fs16.promises.open(outputFile, "w");
     try {
-      const p = await execa(cmd, args, { cwd: dir3, stdout: out, stderr: out, reject: false, env: additionalEnvVars });
+      const p = await execa(cmd, args, {
+        cwd: dir3,
+        stdout: out.fd,
+        stderr: out.fd,
+        reject: false,
+        env: additionalEnvVars
+      });
       this.logger.info(`exitCode of ${cmd} ${args.join(" ")} is ${p.exitCode}`);
       if (p.exitCode === 0) {
         return "OK";
@@ -3954,7 +3963,7 @@ ${formattedIssues.join("\n")}`);
       this.logger.error(`execution of ${summary} failed`, e);
       return "CRASH";
     } finally {
-      await fse12.close(out);
+      await out.close();
     }
   }
   // TODO(imaman): this should be retired. custom build tasks should be used instead.
@@ -3968,8 +3977,8 @@ ${formattedIssues.join("\n")}`);
     }
     const tempFile = await getTempFile();
     const ret = await this.run("npm", ["run", this.scriptNames.postBuild], dir3, tempFile);
-    const toAppend = await fse12.readFile(tempFile);
-    await fse12.appendFile(outputFile, toAppend);
+    const toAppend = await fs16.promises.readFile(tempFile);
+    await fs16.promises.appendFile(outputFile, toAppend);
     return ret;
   }
   async checkBuiltFiles(dir3) {
@@ -3978,7 +3987,7 @@ ${formattedIssues.join("\n")}`);
       const inputDir = path15.join(dir3, codeDir);
       const paths = await DirectoryScanner.listPaths(inputDir, { startingPointMustExist: false });
       for (const p of paths) {
-        inputFiles.set(p, fs11.statSync(path15.join(inputDir, p)).mode);
+        inputFiles.set(p, fs16.statSync(path15.join(inputDir, p)).mode);
       }
       const d = path15.join(dir3, `${this.dist()}/${codeDir}`);
       const distFiles = await DirectoryScanner.listPaths(d, { startingPointMustExist: false });
@@ -4004,9 +4013,9 @@ ${formattedIssues.join("\n")}`);
         const resolved = path15.join(d, f);
         if (orig === void 0) {
           this.logger.info(`deleting unmatched dist file: ${f}`);
-          fs11.rmSync(resolved);
+          fs16.rmSync(resolved);
         } else {
-          fs11.chmodSync(resolved, orig);
+          fs16.chmodSync(resolved, orig);
         }
       }
     }
@@ -4026,7 +4035,7 @@ ${formattedIssues.join("\n")}`);
           throw new Error(`cannot execute ${taskName} when its feature toggle is set to ${ft}`);
         }, "off"),
         dormant: /* @__PURE__ */ __name(async () => {
-          fs11.writeFileSync(outputFile, "");
+          fs16.writeFileSync(outputFile, "");
           const ret = "OK";
           return ret;
         }, "dormant"),
@@ -4061,17 +4070,17 @@ ${formattedIssues.join("\n")}`);
       const hasSpecFiles = await this.hasSpecFiles(testsDir);
       if (!hasSpecFiles) {
         this.logger.info(`No *.spec.ts files found in ${testsDir}, skipping test execution`);
-        await fs11.promises.writeFile(outputFile, `No test files found in ${testsDir}
+        await fs16.promises.writeFile(outputFile, `No test files found in ${testsDir}
 `);
         const dirInRepo = this.state.rootDir.unresolve(dir3);
         const resolvedSummaryFile = this.state.rootDir.resolve(dirInRepo.expand(this.testRunSummaryFile));
-        fs11.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
+        fs16.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
         const jof = path15.join(dir3, JEST_OUTPUT_FILE);
-        fs11.writeFileSync(jof, JSON.stringify([]));
+        fs16.writeFileSync(jof, JSON.stringify([]));
         const tempFile2 = await getTempFile();
         const validateResult2 = await this.runValidate(u, dir3, tempFile2);
-        const toAppend2 = await fse12.readFile(tempFile2);
-        await fse12.appendFile(outputFile, toAppend2);
+        const toAppend2 = await fs16.promises.readFile(tempFile2);
+        await fs16.promises.appendFile(outputFile, toAppend2);
         return validateResult2;
       }
       const tempFile = await getTempFile();
@@ -4080,8 +4089,8 @@ ${formattedIssues.join("\n")}`);
         testCommand ? this.runCustomTest(u.id, dir3, taskName, outputFile) : this.runJest(dir3, taskName, outputFile),
         this.runValidate(u, dir3, tempFile)
       ]);
-      const toAppend = await fse12.readFile(tempFile);
-      await fse12.appendFile(outputFile, toAppend);
+      const toAppend = await fs16.promises.readFile(tempFile);
+      await fs16.promises.appendFile(outputFile, toAppend);
       return switchOn(testResult, {
         CRASH: /* @__PURE__ */ __name(() => testResult, "CRASH"),
         FAIL: /* @__PURE__ */ __name(() => testResult, "FAIL"),
@@ -4090,22 +4099,22 @@ ${formattedIssues.join("\n")}`);
     }
     if (taskKind === "pack") {
       const ret = await this.pack(u, dir3);
-      await fse12.writeFile(outputFile, "");
+      await fs16.promises.writeFile(outputFile, "");
       return ret;
     }
     if (taskKind === "publish-assets") {
       const scriptName = this.scriptNames.prepareAssets;
       const fullPath = path15.join(dir3, PREPARED_ASSETS_DIR);
-      await fse12.rm(fullPath, { force: true, recursive: true });
-      await fse12.mkdirp(fullPath);
+      await fs16.promises.rm(fullPath, { force: true, recursive: true });
+      await fse10.mkdirp(fullPath);
       const ret = await this.run("npm", ["run", scriptName], dir3, outputFile);
-      const exists = await fse12.pathExists(fullPath);
+      const exists = await fse10.pathExists(fullPath);
       if (!exists) {
         throw new BuildFailedError(`Output file ${path15.basename(fullPath)} was not created by the ${scriptName} run script in ${dir3}`);
       }
-      const files = await fse12.readdir(fullPath);
+      const files = await fs16.promises.readdir(fullPath);
       await Promise.all(files.map(async (f) => {
-        const contentToPublish = await fse12.readFile(path15.join(fullPath, f));
+        const contentToPublish = await fs16.promises.readFile(path15.join(fullPath, f));
         this.logger.info(`unit ${u.id}: publishing asset ${f}`);
         const casAddress = await this.assetPublisher.publishAsset(u, contentToPublish, f);
         this.logger.info(`unit ${u.id}: asset ${f} published to cas ${casAddress}`);
@@ -4122,7 +4131,7 @@ ${formattedIssues.join("\n")}`);
   async runUberBuild(outputFile, taskName) {
     if (this.state.uberBuildPromise) {
       const ret2 = await this.state.uberBuildPromise;
-      await fse12.writeFile(outputFile, ``);
+      await fs16.promises.writeFile(outputFile, ``);
       return ret2;
     }
     this.logger.info(`logging uberbuild in ${outputFile} (triggered by ${taskName})`);
@@ -4136,7 +4145,7 @@ ${formattedIssues.join("\n")}`);
   async runJest(dir3, taskName, outputFile) {
     const dirInRepo = this.state.rootDir.unresolve(dir3);
     const resolvedSummaryFile = this.state.rootDir.resolve(dirInRepo.expand(this.testRunSummaryFile));
-    fs11.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
+    fs16.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
     const jof = path15.join(dir3, JEST_OUTPUT_FILE);
     const testsToRun = await this.computeTestsToRun(jof);
     const reporterOutputFile = (await Tmp4.file()).path;
@@ -4150,14 +4159,14 @@ ${formattedIssues.join("\n")}`);
       "--reporters",
       "default"
     ], dir3, outputFile, this.state.config.additionalJestEnvVars);
-    const readStdout = /* @__PURE__ */ __name(() => fs11.readFileSync(outputFile, "utf-8").trim(), "readStdout");
-    const latest = fs11.readFileSync(reporterOutputFile, "utf-8");
+    const readStdout = /* @__PURE__ */ __name(() => fs16.readFileSync(outputFile, "utf-8").trim(), "readStdout");
+    const latest = fs16.readFileSync(reporterOutputFile, "utf-8");
     if (latest.trim().length === 0) {
       const output = readStdout();
       if (output.length) {
         this.logger.print(`<No Jest tests were invoked. Jest output follows below. latest=${JSON.stringify(latest)}>
 ${output}`);
-        fs11.writeFileSync(jof, JSON.stringify(emptyRerunList));
+        fs16.writeFileSync(jof, JSON.stringify(emptyRerunList));
         return "FAIL";
       }
     }
@@ -4197,7 +4206,7 @@ ${output}`);
       }
     });
     const summary = generateTestRunSummary(this.state.rootDir, reporterOutput);
-    fs11.writeFileSync(resolvedSummaryFile, JSON.stringify(summary));
+    fs16.writeFileSync(resolvedSummaryFile, JSON.stringify(summary));
     const failingCases = reporterOutput.cases.filter((at) => switchOn(at.status, {
       disabled: /* @__PURE__ */ __name(() => false, "disabled"),
       failed: /* @__PURE__ */ __name(() => true, "failed"),
@@ -4207,7 +4216,7 @@ ${output}`);
       todo: /* @__PURE__ */ __name(() => false, "todo")
     }));
     const rerunList = sortBy(failingCases.map((at) => ({ fileName: at.fileName, testCaseFullName: at.testCaseFullName })), (at) => `${at.fileName} ${at.testCaseFullName}`);
-    fs11.writeFileSync(jof, JSON.stringify(RerunList.parse(rerunList)));
+    fs16.writeFileSync(jof, JSON.stringify(RerunList.parse(rerunList)));
     return ret;
   }
   async runCustomTest(unitId, dir3, _taskName, outputFile) {
@@ -4218,7 +4227,7 @@ ${output}`);
     const commandPath = this.state.rootDir.resolve(PathInRepo(testCommand));
     const dirInRepo = this.state.rootDir.unresolve(dir3);
     const resolvedSummaryFile = this.state.rootDir.resolve(dirInRepo.expand(this.testRunSummaryFile));
-    fs11.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
+    fs16.writeFileSync(resolvedSummaryFile, JSON.stringify({}));
     const args = [
       dir3,
       // Package directory absolute path
@@ -4229,8 +4238,8 @@ ${output}`);
     ];
     const ret = await this.run(commandPath, args, dir3, outputFile);
     const jof = path15.join(dir3, JEST_OUTPUT_FILE);
-    if (!fs11.existsSync(jof)) {
-      fs11.writeFileSync(jof, JSON.stringify([]));
+    if (!fs16.existsSync(jof)) {
+      fs16.writeFileSync(jof, JSON.stringify([]));
     }
     return ret;
   }
@@ -4297,23 +4306,23 @@ ${output}`);
     const packDist = path15.join(path15.join(dir3, PACK_DIR), "dist");
     const packDistSrc = path15.join(packDist, this.src);
     const packDistDeps = path15.join(packDist, "deps");
-    fs11.mkdirSync(packDistSrc, { recursive: true });
-    fs11.cpSync(path15.join(dir3, this.dist("s")), packDistSrc, { recursive: true });
+    fs16.mkdirSync(packDistSrc, { recursive: true });
+    fs16.cpSync(path15.join(dir3, this.dist("s")), packDistSrc, { recursive: true });
     this.logger.info(`updated packagejson is ${JSON.stringify(packageDef)}`);
     const packageJsonPath = path15.join(dir3, PACK_DIR, "package.json");
     const depUnits = this.state.graph.traverseFrom(u.id, { direction: "forward" }).filter((at) => at !== u.id).map((at) => this.unitOf(at));
     for (const at of depUnits) {
       const d = path15.join(packDistDeps, at.id);
-      fs11.mkdirSync(d, { recursive: true });
-      fs11.cpSync(this.state.rootDir.resolve(at.pathInRepo.expand(this.dist("s"))), d, { recursive: true });
+      fs16.mkdirSync(d, { recursive: true });
+      fs16.cpSync(this.state.rootDir.resolve(at.pathInRepo.expand(this.dist("s"))), d, { recursive: true });
     }
     try {
-      fs11.writeFileSync(packageJsonPath, JSON.stringify(packageDef, null, 2));
+      fs16.writeFileSync(packageJsonPath, JSON.stringify(packageDef, null, 2));
     } catch (e) {
       throw new Error(`Failed to write new package definition at ${packageJsonPath}: ${e}`);
     }
     const indexJs = path15.join(dir3, PACK_DIR, this.dist("s"), "index.js");
-    const content = fs11.readFileSync(indexJs, "utf-8");
+    const content = fs16.readFileSync(indexJs, "utf-8");
     const preamble = [
       "(() => {",
       "  const fs = require(`fs`)",
@@ -4331,7 +4340,7 @@ ${output}`);
       "})()",
       ""
     ].join("\n");
-    fs11.writeFileSync(indexJs, preamble + content);
+    fs16.writeFileSync(indexJs, preamble + content);
     return "OK";
   }
   async getYarnInfo(rootDir) {
@@ -4535,10 +4544,10 @@ ${output}`);
         throw new BuildFailedError(`Circular reference detected in build task definition: ${cycle.join(" -> ")}`);
       }
       absPathToIndex.set(fileToRead, absPathToIndex.size);
-      if (!fs11.existsSync(fileToRead)) {
+      if (!fs16.existsSync(fileToRead)) {
         throw new BuildFailedError(`Could no find file ${where} while resolving build task "${name}" from ${originatingFrom}`);
       }
-      const unparsed = JSON.parse(fs11.readFileSync(fileToRead, "utf-8"));
+      const unparsed = JSON.parse(fs16.readFileSync(fileToRead, "utf-8"));
       const parseResult = BuildTaskRecord.safeParse(unparsed);
       if (!parseResult.success) {
         throw new BuildFailedError(`buildTask object (in ${fileToRead}) is not well formed: ${parseResult.error.message}`);
@@ -4555,12 +4564,12 @@ ${output}`);
     }
   }
   async computeTestsToRun(resolved) {
-    const exists = await fse12.pathExists(resolved);
+    const exists = await fse10.pathExists(resolved);
     if (!exists) {
       this.logger.info("jest-output.json does not exist. running everything!");
       return [this.tests];
     }
-    const content = await fse12.readFile(resolved, "utf-8");
+    const content = await fs16.promises.readFile(resolved, "utf-8");
     let parsed;
     try {
       parsed = JSON.parse(content);
@@ -4599,9 +4608,9 @@ function computeUnits(yarnInfo) {
 __name(computeUnits, "computeUnits");
 async function readPackages(rootDir, units) {
   const ret = /* @__PURE__ */ new Map();
-  await promises(units).forEach(20, async (um) => {
+  await promises2(units).forEach(20, async (um) => {
     const p = rootDir.resolve(um.pathInRepo.expand("package.json"));
-    const content = await fse12.readJSON(p);
+    const content = await fse10.readJSON(p);
     ret.set(um.id, content);
   });
   return ret;
@@ -4611,9 +4620,9 @@ async function createOutDirs(rootDir, units, outDirName) {
   if (!outDirName) {
     return;
   }
-  await promises(units).forEach(20, async (um) => {
+  await promises2(units).forEach(20, async (um) => {
     const p = rootDir.resolve(um.pathInRepo.expand(outDirName));
-    await fse12.ensureDir(p);
+    await fse10.ensureDir(p);
   });
 }
 __name(createOutDirs, "createOutDirs");
@@ -4780,7 +4789,7 @@ async function makeBootstrapper(options) {
     throw new Error(`could not find a repo dir (a directory with a package.json file that has a 'workspace' attribute) in or above ${userDir}`);
   }
   const buildRaptorDir = path16.join(rootDir, ".build-raptor");
-  await fse13.ensureDir(buildRaptorDir);
+  await fse11.ensureDir(buildRaptorDir);
   const logFile = path16.join(buildRaptorDir, "main.log");
   const logger = createDefaultLogger(logFile, options.criticality);
   logger.info(`Logger initialized`);
@@ -4799,7 +4808,7 @@ async function makeBootstrapper(options) {
 ${JSON.stringify({ isCi, commitHash, startedAt: new Date(t0).toISOString() }, null, 2)}`);
   }
   const buildRaptorDirTasks = path16.join(buildRaptorDir, "tasks");
-  await fse13.rm(buildRaptorDirTasks, { recursive: true, force: true });
+  await fs17.promises.rm(buildRaptorDirTasks, { recursive: true, force: true });
   const storageClient = await storageClientFactory(logger);
   const assetPublisher = new DefaultAssetPublisher(storageClient, logger);
   const repoProtocol = new YarnRepoProtocol(logger, assetPublisher);
@@ -4808,7 +4817,7 @@ ${JSON.stringify({ isCi, commitHash, startedAt: new Date(t0).toISOString() }, nu
   const visualizer = options.taskProgressOutput ? new TaskExecutionVisualizer() : void 0;
   const taskTimings = options.printTiming ? /* @__PURE__ */ new Map() : void 0;
   const allTestsFile = path16.join(buildRaptorDir, "all-tests");
-  fs12.writeFileSync(allTestsFile, "");
+  fs17.writeFileSync(allTestsFile, "");
   let atLeastOneTest = false;
   bootstrapper.transmitter.addProcessor((s) => {
     if (s.step === "ASSET_PUBLISHED" || s.step === "BUILD_RUN_STARTED" || s.step === "PUBLIC_FILES" || s.step === "TASK_STORE_GET" || s.step === "TASK_STORE_PUT") {
@@ -4869,9 +4878,9 @@ ${whereIsTheLogMessage}${line}`);
     }
   });
   bootstrapper.subscribable.on("executionEnded", async (arg) => {
-    await fse13.ensureDir(buildRaptorDirTasks);
+    await fse11.ensureDir(buildRaptorDirTasks);
     const fileName = path16.join(buildRaptorDirTasks, toReasonableFileName(arg.taskName));
-    const stream2 = fse13.createWriteStream(fileName);
+    const stream2 = fs17.createWriteStream(fileName);
     try {
       await dumpFile(arg.outputFile, stream2);
       logger.info(`wrote output of ${arg.taskName} to ${fileName}`);
@@ -4892,7 +4901,7 @@ ${whereIsTheLogMessage}${line}`);
 
 `);
     }
-    fs12.appendFileSync(allTestsFile, fs12.readFileSync(arg.outputFile) + "\n");
+    fs17.appendFileSync(allTestsFile, fs17.readFileSync(arg.outputFile) + "\n");
     logger.info(`output of ${arg.taskName} dumped`);
   });
   bootstrapper.subscribable.on("executionSkipped", (tn) => {
@@ -4976,7 +4985,7 @@ function reportTests(logger, arr, tr, allTasksFile) {
       const duration = at.durationMillis === void 0 ? "" : ` (${at.durationMillis} ms)`;
       const message = `${spaces}${v} ${at.testPath.at(-1)}${duration}`;
       logger.print(message, "high");
-      fs12.appendFileSync(allTasksFile, message + "\n");
+      fs17.appendFileSync(allTasksFile, message + "\n");
       prev = k;
     }
   }
@@ -4986,13 +4995,13 @@ function reportTests(logger, arr, tr, allTasksFile) {
   const passing = sorted.filter((at) => isPassing(at.tests));
   for (const at of passing) {
     const message = `\u2705 PASSED ${at.fileName}`;
-    fs12.appendFileSync(allTasksFile, message + "\n");
+    fs17.appendFileSync(allTasksFile, message + "\n");
     if (renderPassingTests) {
       logger.print(message, "high");
     }
   }
   for (const at of sorted.filter((at2) => !isPassing(at2.tests))) {
-    fs12.appendFileSync(allTasksFile, at.fileName + "\n");
+    fs17.appendFileSync(allTasksFile, at.fileName + "\n");
     logger.print(at.fileName, "high");
     printTests(at.tests);
   }