executable-stories-formatters 0.7.9 → 0.7.11

package/dist/cli.js

@@ -2,8 +2,8 @@
 
 // src/cli.ts
 import { parseArgs } from "util";
-import * as fs7 from "fs";
-import * as path7 from "path";
+import * as fs8 from "fs";
+import * as path8 from "path";
 
 // src/validation/schema-validator.ts
 import Ajv from "ajv/dist/2020.js";
@@ -492,17 +492,17 @@ function validateRawRun(data) {
     return { valid: true, errors: [] };
   }
   const errors = (validate.errors ?? []).map((err) => {
-    const path8 = err.instancePath || "/";
+    const path9 = err.instancePath || "/";
     const message = err.message ?? "unknown error";
     if (err.keyword === "additionalProperties") {
       const extra = err.params.additionalProperty;
-      return `${path8}: ${message} \u2014 '${extra}'`;
+      return `${path9}: ${message} \u2014 '${extra}'`;
     }
     if (err.keyword === "enum") {
       const allowed = err.params.allowedValues;
-      return `${path8}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
+      return `${path9}: ${message} \u2014 allowed: ${JSON.stringify(allowed)}`;
     }
-    return `${path8}: ${message}`;
+    return `${path9}: ${message}`;
   });
   return { valid: false, errors };
 }
@@ -966,7 +966,7 @@ ${result.errors.join("\n")}`);
 
 // src/index.ts
 import "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import * as fsPromises from "fs/promises";
 
 // src/converters/acl/lines.ts
@@ -1330,6 +1330,10 @@ ${doc.markdown}`,
   }
 };
 
+// src/formatters/html/renderers/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+
 // src/formatters/html/template.ts
 var JS_THEME = `
 // Theme management
@@ -13637,7 +13641,9 @@ function renderDocMermaid(entry, deps) {
 }
 function renderDocScreenshot(entry, deps) {
   const alt = entry.alt ?? "Screenshot";
-  const src = entry.path;
+  const embedEnabled = deps.embedScreenshots ?? true;
+  const isRemote = /^(?:https?:|data:)/i.test(entry.path);
+  const src = embedEnabled && !isRemote && deps.readScreenshot ? deps.readScreenshot(entry.path) ?? entry.path : entry.path;
   return `<div class="doc-screenshot">
   <img src="${deps.escapeHtml(src)}" alt="${deps.escapeHtml(alt)}" class="doc-screenshot-img" />
   ${entry.alt ? `<div class="doc-screenshot-caption">${deps.escapeHtml(entry.alt)}</div>` : ""}
@@ -14219,6 +14225,28 @@ function renderToc(args, deps) {
 }
 
 // src/formatters/html/renderers/index.ts
+var SCREENSHOT_MIME_BY_EXT = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  avif: "image/avif",
+  bmp: "image/bmp"
+};
+function readScreenshotAsDataUri(filePath) {
+  try {
+    const ext = path2.extname(filePath).slice(1).toLowerCase();
+    const mime = SCREENSHOT_MIME_BY_EXT[ext];
+    if (!mime) return void 0;
+    if (!fs2.existsSync(filePath)) return void 0;
+    const buf = fs2.readFileSync(filePath);
+    return `data:${mime};base64,${buf.toString("base64")}`;
+  } catch {
+    return void 0;
+  }
+}
 function normalizeOptions(options = {}) {
   return {
     title: options.title ?? "Test Results",
@@ -14242,7 +14270,9 @@ function createHtmlFormatter(options = {}) {
     escapeHtml,
     syntaxHighlighting: opts.syntaxHighlighting,
     markdownEnabled: opts.markdownEnabled,
-    mermaidEnabled: opts.mermaidEnabled
+    mermaidEnabled: opts.mermaidEnabled,
+    embedScreenshots: opts.embedScreenshots,
+    readScreenshot: (filePath) => readScreenshotAsDataUri(filePath)
   };
   const renderDocs = (docs, containerClass) => {
     if (!docs || docs.length === 0) return "";
@@ -15671,8 +15701,8 @@ function extractDocAttachments(step) {
   }
   return attachments;
 }
-function guessMediaType(path8) {
-  const lower = path8.toLowerCase();
+function guessMediaType(path9) {
+  const lower = path9.toLowerCase();
   if (lower.endsWith(".png")) return "image/png";
   if (lower.endsWith(".jpg") || lower.endsWith(".jpeg")) return "image/jpeg";
   if (lower.endsWith(".gif")) return "image/gif";
@@ -16746,8 +16776,8 @@ function selectTestCases(args, deps) {
 }
 
 // src/bundler/bundle-assets.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
+import * as fs4 from "fs";
+import * as path4 from "path";
 
 // src/bundler/scan-html-assets.ts
 function scanHtmlAssets(html) {
@@ -16777,21 +16807,21 @@ function isLocalAssetRef(ref) {
 }
 
 // src/bundler/copy-asset.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs3 from "fs";
+import * as path3 from "path";
 import * as crypto from "crypto";
 function copyAsset(sourcePath, assetsDir) {
-  if (!fs2.existsSync(assetsDir)) {
-    fs2.mkdirSync(assetsDir, { recursive: true });
+  if (!fs3.existsSync(assetsDir)) {
+    fs3.mkdirSync(assetsDir, { recursive: true });
   }
-  const content = fs2.readFileSync(sourcePath);
+  const content = fs3.readFileSync(sourcePath);
   const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-  const ext = path2.extname(sourcePath);
-  const baseName = sanitize(path2.basename(sourcePath, ext));
+  const ext = path3.extname(sourcePath);
+  const baseName = sanitize(path3.basename(sourcePath, ext));
   const destName = `${baseName}-${hash}${ext}`;
-  const destPath = path2.join(assetsDir, destName);
-  if (!fs2.existsSync(destPath)) {
-    fs2.copyFileSync(sourcePath, destPath);
+  const destPath = path3.join(assetsDir, destName);
+  if (!fs3.existsSync(destPath)) {
+    fs3.copyFileSync(sourcePath, destPath);
   }
   return `assets/${destName}`;
 }
@@ -16801,15 +16831,15 @@ function sanitize(name) {
 
 // src/bundler/bundle-assets.ts
 function bundleAssets(htmlPath, options = {}) {
-  const htmlDir = path3.dirname(htmlPath);
-  const assetsDir = path3.join(htmlDir, "assets");
-  let html = fs3.readFileSync(htmlPath, "utf8");
+  const htmlDir = path4.dirname(htmlPath);
+  const assetsDir = path4.join(htmlDir, "assets");
+  let html = fs4.readFileSync(htmlPath, "utf8");
   const refs = scanHtmlAssets(html);
   let copiedCount = 0;
   const missing = [];
   for (const ref of refs) {
-    const absolutePath = path3.resolve(htmlDir, ref);
-    if (!fs3.existsSync(absolutePath)) {
+    const absolutePath = path4.resolve(htmlDir, ref);
+    if (!fs4.existsSync(absolutePath)) {
       missing.push(ref);
       continue;
     }
@@ -16822,7 +16852,7 @@ function bundleAssets(htmlPath, options = {}) {
       `Missing asset${missing.length > 1 ? "s" : ""}: ${missing.join(", ")}`
     );
   }
-  fs3.writeFileSync(htmlPath, html, "utf8");
+  fs4.writeFileSync(htmlPath, html, "utf8");
   return {
     copiedCount,
     missingCount: missing.length,
@@ -17305,15 +17335,15 @@ function groupBy7(items, keyFn) {
 }
 
 // src/formatters/astro-assets.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 var SKIP_PREFIXES = ["http://", "https://", "data:", "#"];
 function isLocalPath(src) {
   const trimmed = src.trim();
   if (SKIP_PREFIXES.some((prefix) => trimmed.startsWith(prefix))) {
     return false;
   }
-  return !path4.posix.isAbsolute(trimmed) && !path4.win32.isAbsolute(trimmed);
+  return !path5.posix.isAbsolute(trimmed) && !path5.win32.isAbsolute(trimmed);
 }
 function stripCodeContent(markdown) {
   let result = markdown.replace(/^[ \t]*(`{3,}|~{3,})[^\n]*\n[\s\S]*?^[ \t]*\1\s*$/gm, "");
@@ -17407,8 +17437,8 @@ function copyMarkdownAssets(options) {
   const pathMap = /* @__PURE__ */ new Map();
   const missing = [];
   for (const ref of refs) {
-    const absPath = path4.resolve(markdownDir, ref);
-    if (!fs4.existsSync(absPath)) {
+    const absPath = path5.resolve(markdownDir, ref);
+    if (!fs5.existsSync(absPath)) {
       if (!allowMissing) {
         throw new Error(`Asset not found: ${absPath}`);
       }
@@ -18716,11 +18746,11 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   const ext = FORMAT_EXTENSIONS[format];
   const effectiveName = outputName + (outputNameSuffix ?? "");
   if (mode === "aggregated") {
-    return toPosix(path5.join(baseOutputDir, `${effectiveName}${ext}`));
+    return toPosix(path6.join(baseOutputDir, `${effectiveName}${ext}`));
   }
   const normalizedSource = toPosix(sourceFile);
-  const dirOfSource = path5.posix.dirname(normalizedSource);
-  let baseName = path5.posix.basename(normalizedSource);
+  const dirOfSource = path6.posix.dirname(normalizedSource);
+  let baseName = path6.posix.basename(normalizedSource);
   for (const testExt of TEST_EXTENSIONS) {
     if (baseName.endsWith(testExt)) {
       baseName = baseName.slice(0, -testExt.length);
@@ -18729,9 +18759,9 @@ function computeOutputPath(sourceFile, format, mode, colocatedStyle, baseOutputD
   }
   const fileName = `${baseName}.${effectiveName}${ext}`;
   if (colocatedStyle === "adjacent") {
-    return toPosix(path5.posix.join(dirOfSource, fileName));
+    return toPosix(path6.posix.join(dirOfSource, fileName));
   }
-  return toPosix(path5.posix.join(baseOutputDir, dirOfSource, fileName));
+  return toPosix(path6.posix.join(baseOutputDir, dirOfSource, fileName));
 }
 function groupTestCasesByOutput(testCases, format, options, logger, outputNameSuffix) {
   const groups = /* @__PURE__ */ new Map();
@@ -18929,8 +18959,8 @@ var ReportGenerator = class {
       if (astroPaths) {
         for (const mdPath of astroPaths) {
           const content = await fsPromises.readFile(mdPath, "utf8");
-          const mdDir = path5.dirname(mdPath);
-          const assetsDir = path5.resolve(this.options.astro.assetsDir);
+          const mdDir = path6.dirname(mdPath);
+          const assetsDir = path6.resolve(this.options.astro.assetsDir);
           const result = copyMarkdownAssets({
             markdown: content,
             markdownDir: mdDir,
@@ -18961,9 +18991,9 @@ var ReportGenerator = class {
     if (groups.size === 0 && this.options.output.mode === "aggregated") {
       const ext = FORMAT_EXTENSIONS[format];
       const effectiveName = this.options.outputName + (outputNameSuffix ?? "");
-      const outputPath = toPosix(path5.join(this.options.outputDir, `${effectiveName}${ext}`));
+      const outputPath = toPosix(path6.join(this.options.outputDir, `${effectiveName}${ext}`));
       const content = await this.formatContent(run, format);
-      const dir = path5.dirname(outputPath);
+      const dir = path6.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       return [outputPath];
@@ -18975,7 +19005,7 @@ var ReportGenerator = class {
         testCases
       };
       const content = await this.formatContent(groupRun, format);
-      const dir = path5.dirname(outputPath);
+      const dir = path6.dirname(outputPath);
       await fsPromises.mkdir(dir, { recursive: true });
       await this.deps.writeFile(outputPath, content);
       writtenPaths.push(outputPath);
@@ -19095,7 +19125,7 @@ async function generateRunComparison(args) {
   await fsPromises.mkdir(outputDir, { recursive: true });
   for (const format of args.formats) {
     const ext = format === "html" ? ".html" : ".md";
-    const outputPath = toPosix(path5.join(outputDir, `${outputName}${ext}`));
+    const outputPath = toPosix(path6.join(outputDir, `${outputName}${ext}`));
     const content = format === "html" ? new RunDiffHtmlFormatter({ title: args.title }).format(diff) : new RunDiffMarkdownFormatter({ title: args.title }).format(diff);
     await fsPromises.writeFile(outputPath, content, "utf8");
     files.push(outputPath);
@@ -19104,23 +19134,23 @@ async function generateRunComparison(args) {
 }
 
 // src/init-astro.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs7 from "fs";
+import * as path7 from "path";
 import { fileURLToPath } from "url";
-var __dirname = path6.dirname(fileURLToPath(import.meta.url));
+var __dirname = path7.dirname(fileURLToPath(import.meta.url));
 function initAstro(options = {}) {
   const targetDir = options.targetDir ?? "./story-docs";
   const force = options.force ?? false;
-  if (fs6.existsSync(targetDir)) {
-    const entries = fs6.readdirSync(targetDir);
+  if (fs7.existsSync(targetDir)) {
+    const entries = fs7.readdirSync(targetDir);
     if (entries.length > 0 && !force) {
       throw new Error(
         `Directory "${targetDir}" already exists and is not empty. Use --force to overwrite.`
       );
     }
   }
-  const templateDir = path6.resolve(__dirname, "..", "templates", "astro-starlight");
-  if (!fs6.existsSync(templateDir)) {
+  const templateDir = path7.resolve(__dirname, "..", "templates", "astro-starlight");
+  if (!fs7.existsSync(templateDir)) {
     throw new Error(
       `Template directory not found at ${templateDir}. Ensure the package is installed correctly.`
     );
@@ -19129,25 +19159,25 @@ function initAstro(options = {}) {
   return { targetDir };
 }
 function copyDirRecursive(src, dest) {
-  fs6.mkdirSync(dest, { recursive: true });
-  const entries = fs6.readdirSync(src, { withFileTypes: true });
+  fs7.mkdirSync(dest, { recursive: true });
+  const entries = fs7.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
-    const srcPath = path6.join(src, entry.name);
-    const destPath = path6.join(dest, entry.name);
+    const srcPath = path7.join(src, entry.name);
+    const destPath = path7.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
-      fs6.copyFileSync(srcPath, destPath);
+      fs7.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/config.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 import { resolve as resolve6 } from "path";
 async function loadConfig(configPath) {
   const resolved = configPath ? resolve6(configPath) : resolve6(process.cwd(), "executable-stories.config.js");
-  if (!existsSync6(resolved)) return {};
+  if (!existsSync7(resolved)) return {};
   const mod = await import(resolved);
   const config = mod.default;
   if (!config || typeof config !== "object" || Array.isArray(config)) {
@@ -19566,20 +19596,20 @@ async function readInput(args) {
   if (args.stdin) {
     return readStdin();
   }
-  const filePath = path7.resolve(args.inputFile);
-  if (!fs7.existsSync(filePath)) {
+  const filePath = path8.resolve(args.inputFile);
+  if (!fs8.existsSync(filePath)) {
     console.error(`Error: File not found: ${filePath}`);
     process.exit(EXIT_USAGE);
   }
-  return fs7.readFileSync(filePath, "utf8");
+  return fs8.readFileSync(filePath, "utf8");
 }
 function readFileInput(filePath) {
-  const resolved = path7.resolve(filePath);
-  if (!fs7.existsSync(resolved)) {
+  const resolved = path8.resolve(filePath);
+  if (!fs8.existsSync(resolved)) {
     console.error(`Error: File not found: ${resolved}`);
     process.exit(EXIT_USAGE);
   }
-  return fs7.readFileSync(resolved, "utf8");
+  return fs8.readFileSync(resolved, "utf8");
 }
 function readStdin() {
   return new Promise((resolve8, reject) => {
@@ -19712,14 +19742,14 @@ function tryNormalizeRunFromText(text2, args) {
   }
 }
 function listBaselineCandidates(currentFile, args) {
-  const baselineDir = path7.resolve(args.baselineDir ?? path7.dirname(currentFile));
-  const currentResolved = path7.resolve(currentFile);
-  if (!fs7.existsSync(baselineDir)) {
+  const baselineDir = path8.resolve(args.baselineDir ?? path8.dirname(currentFile));
+  const currentResolved = path8.resolve(currentFile);
+  if (!fs8.existsSync(baselineDir)) {
     console.error(`Error: baseline directory not found: ${baselineDir}`);
     process.exit(EXIT_USAGE);
   }
-  const entries = fs7.readdirSync(baselineDir, { withFileTypes: true });
-  return entries.filter((entry) => entry.isFile()).map((entry) => path7.join(baselineDir, entry.name)).filter((candidate) => path7.resolve(candidate) !== currentResolved).filter(
+  const entries = fs8.readdirSync(baselineDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isFile()).map((entry) => path8.join(baselineDir, entry.name)).filter((candidate) => path8.resolve(candidate) !== currentResolved).filter(
     (candidate) => args.inputType === "ndjson" ? candidate.endsWith(".ndjson") : candidate.endsWith(".json")
   );
 }
@@ -19727,14 +19757,14 @@ function resolveBaselineAuto(currentFile, currentRun, args) {
   const candidates = listBaselineCandidates(currentFile, args);
   const comparable = [];
   for (const candidate of candidates) {
-    const run = tryNormalizeRunFromText(fs7.readFileSync(candidate, "utf8"), args);
+    const run = tryNormalizeRunFromText(fs8.readFileSync(candidate, "utf8"), args);
     if (run) {
       comparable.push({ file: candidate, run });
     }
   }
   if (comparable.length === 0) {
     console.error(
-      `Error: no compatible baseline files found in ${path7.resolve(args.baselineDir ?? path7.dirname(currentFile))}.`
+      `Error: no compatible baseline files found in ${path8.resolve(args.baselineDir ?? path8.dirname(currentFile))}.`
     );
     process.exit(EXIT_USAGE);
   }
@@ -19823,9 +19853,9 @@ async function main() {
       process.exit(EXIT_SCHEMA_VALIDATION);
     }
     if (args.emitCanonical) {
-      const outPath = path7.resolve(args.emitCanonical);
-      fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
-      fs7.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path8.resolve(args.emitCanonical);
+      fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+      fs8.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
@@ -19882,9 +19912,9 @@ ${msg}`);
     }
     const run = data;
     if (args.emitCanonical) {
-      const outPath = path7.resolve(args.emitCanonical);
-      fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
-      fs7.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
+      const outPath = path8.resolve(args.emitCanonical);
+      fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+      fs8.writeFileSync(outPath, JSON.stringify(run, null, 2), "utf8");
     }
     try {
       const result = await generateReports(run, args);
@@ -19940,9 +19970,9 @@ ${msg}`);
     process.exit(EXIT_CANONICAL_VALIDATION);
   }
   if (args.emitCanonical) {
-    const outPath = path7.resolve(args.emitCanonical);
-    fs7.mkdirSync(path7.dirname(outPath), { recursive: true });
-    fs7.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
+    const outPath = path8.resolve(args.emitCanonical);
+    fs8.mkdirSync(path8.dirname(outPath), { recursive: true });
+    fs8.writeFileSync(outPath, JSON.stringify(canonical, null, 2), "utf8");
   }
   try {
     const result = await generateReports(canonical, args, droppedMissingStory);
@@ -19967,9 +19997,9 @@ function runCustomFormatters(run, customRequested, formatters, args) {
       const ext = formatter.fileExtension ?? formatName;
       const baseName = args.outputName ?? "report";
       const filename = args.outputNameTimestamp ? `${baseName}-${Math.floor(run.startedAtMs / 1e3)}.${ext}` : `${baseName}.${ext}`;
-      const filepath = path7.join(outputDir, filename);
-      fs7.mkdirSync(outputDir, { recursive: true });
-      fs7.writeFileSync(filepath, content, "utf8");
+      const filepath = path8.join(outputDir, filename);
+      fs8.mkdirSync(outputDir, { recursive: true });
+      fs8.writeFileSync(filepath, content, "utf8");
       console.log(`Generated: ${filepath}`);
     } catch (err) {
       console.error(`Error running custom formatter "${formatName}": ${err instanceof Error ? err.message : String(err)}`);
@@ -20019,13 +20049,13 @@ async function dispatchNotifications(run, args) {
 }
 function runHistoryPipeline(run, args) {
   if (!args.historyFile) return;
-  const historyPath = path7.resolve(args.historyFile);
+  const historyPath = path8.resolve(args.historyFile);
   const store = loadHistory(
     { filePath: historyPath },
     {
       readFile: (p) => {
         try {
-          return fs7.readFileSync(p, "utf8");
+          return fs8.readFileSync(p, "utf8");
         } catch {
           return void 0;
         }
@@ -20038,11 +20068,11 @@ function runHistoryPipeline(run, args) {
     run,
     maxRuns: args.maxHistoryRuns
   });
-  const dir = path7.dirname(historyPath);
-  fs7.mkdirSync(dir, { recursive: true });
+  const dir = path8.dirname(historyPath);
+  fs8.mkdirSync(dir, { recursive: true });
   saveHistory(
     { filePath: historyPath, store: updated },
-    { writeFile: (p, content) => fs7.writeFileSync(p, content, "utf8") }
+    { writeFile: (p, content) => fs8.writeFileSync(p, content, "utf8") }
   );
   let metricsCount = 0;
   for (const testId of Object.keys(updated.tests)) {
@@ -20140,9 +20170,9 @@ function printResult(result, args, startMs, droppedMissingStory = 0) {
 function printCompareResult(result, args, startMs) {
   const durationMs = Date.now() - startMs;
   if (result.prSummary && args.prSummaryFile) {
-    const outputPath = path7.resolve(args.prSummaryFile);
-    fs7.mkdirSync(path7.dirname(outputPath), { recursive: true });
-    fs7.writeFileSync(outputPath, result.prSummary, "utf8");
+    const outputPath = path8.resolve(args.prSummaryFile);
+    fs8.mkdirSync(path8.dirname(outputPath), { recursive: true });
+    fs8.writeFileSync(outputPath, result.prSummary, "utf8");
   }
   if (args.jsonSummary) {
     console.log(
@@ -20213,7 +20243,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: missing ADF file argument. Run with --help for usage.");
     process.exit(EXIT_USAGE);
   }
-  if (!fs7.existsSync(inputFile)) {
+  if (!fs8.existsSync(inputFile)) {
     console.error(`Error: file not found: ${inputFile}`);
     process.exit(EXIT_USAGE);
   }
@@ -20241,7 +20271,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: --title is required when creating a new page");
     process.exit(EXIT_USAGE);
   }
-  const adf = fs7.readFileSync(path7.resolve(inputFile), "utf8");
+  const adf = fs8.readFileSync(path8.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(
@@ -20320,7 +20350,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     console.error("Error: missing ADF file argument. Run with --help for usage.");
     process.exit(EXIT_USAGE);
   }
-  if (!fs7.existsSync(inputFile)) {
+  if (!fs8.existsSync(inputFile)) {
     console.error(`Error: file not found: ${inputFile}`);
     process.exit(EXIT_USAGE);
   }
@@ -20347,7 +20377,7 @@ Generate an API token at https://id.atlassian.com/manage-profile/security/api-to
     process.exit(EXIT_USAGE);
   }
   const mode = modeRaw;
-  const adf = fs7.readFileSync(path7.resolve(inputFile), "utf8");
+  const adf = fs8.readFileSync(path8.resolve(inputFile), "utf8");
   if (dryRun) {
     console.log(
       JSON.stringify(