bytecut 0.0.0-stage → 0.1.0

package/dist/chunk-XUBQWBWH.js

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+import {
+  outputWidth,
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import {
+  BUILTIN_POLICY,
+  getVideoPreset
+} from "./chunk-3PF6BBFK.js";
+import {
+  BytecutError
+} from "./chunk-FY53B4NB.js";
+
+// src/core/classify/classify.ts
+var FLAT_COLOR_LIMIT = 64;
+var ICON_MAX_EDGE = 1024;
+var HERO_NAME = /(^|[^a-z])(hero|banner|cover|header|splash|masthead|jumbotron)([^a-z]|$)/i;
+var ICON_NAME = /(^|[^a-z])(icon|logo|favicon|sprite|glyph)([^a-z]|$)/i;
+function baseName(source) {
+  const name = source.slice(source.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function classify(source, a) {
+  const name = baseName(source);
+  const longEdge = Math.max(a.width, a.height);
+  const flat = a.sampleSize > 0 && a.colorCount <= FLAT_COLOR_LIMIT;
+  if (flat && longEdge <= ICON_MAX_EDGE) {
+    const named = ICON_NAME.test(name);
+    return {
+      preset: "icon",
+      confidence: named || a.alphaUsed || longEdge <= 512 ? "high" : "medium",
+      reason: `flat art (${a.colorCount} colours in sample${a.alphaUsed ? ", uses transparency" : ""}${named ? `, name "${name}"` : ""})`
+    };
+  }
+  if (!flat && ICON_NAME.test(name) && longEdge <= 256) {
+    return {
+      preset: "icon",
+      confidence: "medium",
+      reason: `small image named "${name}" (${longEdge}px)`
+    };
+  }
+  if (HERO_NAME.test(name)) {
+    return { preset: "hero", confidence: "high", reason: `name "${name}" looks like a hero image` };
+  }
+  if (a.width >= 1920 && a.width / Math.max(1, a.height) >= 1.6) {
+    return {
+      preset: "hero",
+      confidence: "medium",
+      reason: `large wide image (${a.width}x${a.height})`
+    };
+  }
+  const confident = a.colorCount > FLAT_COLOR_LIMIT * 2;
+  return {
+    preset: "photo",
+    confidence: confident ? "high" : "low",
+    reason: confident ? "continuous-tone image" : "ambiguous content; using the conservative preset"
+  };
+}
+
+// src/core/hash.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function sha256File(path) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+// src/core/plan/build.ts
+import { posix, relative } from "path";
+function targetWidths(presetWidths, sourceWidth) {
+  const widths = presetWidths.filter((w) => w <= sourceWidth);
+  const largest = Math.max(...presetWidths);
+  if (sourceWidth < largest && !widths.includes(sourceWidth)) widths.push(sourceWidth);
+  return [...new Set(widths)].sort((a, b) => a - b);
+}
+function outputWidths(preset, sourceWidth, sourceHeight) {
+  if (preset.maxEdge === void 0) return targetWidths(preset.widths, sourceWidth);
+  const longest = Math.max(sourceWidth, sourceHeight);
+  if (longest <= preset.maxEdge) return [sourceWidth];
+  return [Math.max(1, Math.floor(sourceWidth * preset.maxEdge / longest))];
+}
+function formatsFor(preset, analysis, confidence) {
+  const ambiguousPng = analysis.format === "png" && confidence === "low";
+  const needsPng = analysis.alphaUsed || preset.lossless === true || ambiguousPng;
+  const out = preset.formats.map((f) => f === "jpg" && needsPng ? "png" : f);
+  return [...new Set(out)];
+}
+function mirroredDir(source, staticRoot) {
+  const dir = posix.dirname(source);
+  if (staticRoot !== "." && staticRoot !== "") {
+    if (dir === staticRoot) return "";
+    if (dir.startsWith(`${staticRoot}/`)) return dir.slice(staticRoot.length + 1);
+  }
+  return dir === "." ? "" : dir;
+}
+var DEFAULT_PUBLIC_PATH = "/_bytecut";
+var ANIMATED_GIF_REASON = "animated GIF";
+async function buildPlan(options) {
+  const items = [];
+  const claimed = /* @__PURE__ */ new Map();
+  const staticRoot = options.staticRoot ?? ".";
+  const analyze = options.analyze ?? ((data) => options.engine.analyze(data));
+  const files = options.files.map((file) => ({ file, source: toPosix(relative(options.projectRoot, file)) })).sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+  for (const { file, source } of files) {
+    if (source.startsWith("../") || source === "..") {
+      throw new BytecutError(
+        "SOURCE_OUTSIDE_PROJECT",
+        `${file} is outside the project root (${options.projectRoot}); run bytecut from a parent folder.`
+      );
+    }
+    const data = await options.readSource(file);
+    const digest = sha256(data);
+    const base = {
+      source,
+      sourceBytes: data.byteLength,
+      sourceSha256: digest,
+      sourceWidth: 0,
+      sourceHeight: 0
+    };
+    let analysis;
+    try {
+      analysis = await analyze(data, digest);
+    } catch {
+      items.push({
+        ...base,
+        preset: "-",
+        outputs: [],
+        skip: { reason: "unreadable or corrupt image" }
+      });
+      continue;
+    }
+    const sized = { ...base, sourceWidth: analysis.width, sourceHeight: analysis.height };
+    if (analysis.format === "other") {
+      items.push({
+        ...sized,
+        preset: "-",
+        outputs: [],
+        skip: { reason: "unsupported image format" }
+      });
+      continue;
+    }
+    if (analysis.animated) {
+      const reason = analysis.format === "gif" ? `${ANIMATED_GIF_REASON} (video conversion arrives with ffmpeg support in M5)` : "animated image";
+      items.push({ ...sized, preset: "-", outputs: [], skip: { reason } });
+      continue;
+    }
+    const choice = options.choosePreset(source, analysis);
+    const { preset } = choice;
+    const dir = mirroredDir(source, staticRoot);
+    const name = posix.basename(source, posix.extname(source));
+    const outputs = [];
+    for (const width of outputWidths(preset, analysis.width, analysis.height)) {
+      for (const format of formatsFor(preset, analysis, choice.confidence)) {
+        const lossless = format === "png" || (preset.lossless ?? (analysis.format === "png" && format === "webp"));
+        const path = posix.join(dir, name, `${name}-${width}.${format}`);
+        const owner = claimed.get(path);
+        if (owner !== void 0) {
+          throw new BytecutError(
+            "OUTPUT_COLLISION",
+            `${source} and ${owner} would both write ${path}. Rename one of them.`
+          );
+        }
+        claimed.set(path, source);
+        outputs.push({
+          path,
+          format,
+          width,
+          lossless,
+          ...preset.encoders[format],
+          // A lossless output is exact; there is nothing to search for.
+          ...preset.search && !lossless ? { search: { ...preset.search } } : {}
+        });
+      }
+    }
+    items.push({
+      ...sized,
+      preset: preset.name,
+      classification: {
+        reason: choice.reason,
+        ...choice.confidence ? { confidence: choice.confidence } : {}
+      },
+      outputs
+    });
+  }
+  return {
+    version: 1,
+    outDir: toPosix(relative(options.projectRoot, options.outDir)) || ".",
+    publicPath: options.publicPath ?? DEFAULT_PUBLIC_PATH,
+    items
+  };
+}
+
+// src/core/classify/video.ts
+var BACKGROUND_NAME = /(^|[^a-z])(bg|background|backdrop|loop|ambient|hero|banner|header|splash|texture|cover)([^a-z]|$)/i;
+var BACKGROUND_MAX_SECONDS = 45;
+function baseName2(source) {
+  const name = source.slice(source.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function classifyVideo(source, probe) {
+  const name = baseName2(source);
+  const named = BACKGROUND_NAME.test(name);
+  const short = probe.durationSec > 0 && probe.durationSec <= BACKGROUND_MAX_SECONDS;
+  if (!probe.hasAudio && short) {
+    return {
+      preset: "background-video",
+      confidence: named ? "high" : "medium",
+      reason: `silent ${probe.durationSec.toFixed(0)}s clip${named ? `, name "${name}"` : ""}`
+    };
+  }
+  if (named && short && probe.hasAudio) {
+    return {
+      preset: "background-video",
+      confidence: "medium",
+      reason: `name "${name}" and ${probe.durationSec.toFixed(0)}s long; its audio track will be removed`
+    };
+  }
+  return {
+    preset: "content-video",
+    confidence: probe.hasAudio ? "high" : "low",
+    reason: probe.hasAudio ? "has an audio track, so it is treated as content" : "long silent video; keeping resolution and frame rate"
+  };
+}
+
+// src/core/plan/video.ts
+import { stat } from "fs/promises";
+import { posix as posix2, relative as relative2 } from "path";
+function skipped(source, bytes, sha, reason, extra = {}) {
+  return {
+    source,
+    sourceBytes: bytes,
+    sourceSha256: sha,
+    sourceWidth: 0,
+    sourceHeight: 0,
+    durationSec: 0,
+    fps: 0,
+    hasAudio: false,
+    videoCodec: "unknown",
+    preset: "-",
+    outputs: [],
+    skip: { reason },
+    ...extra
+  };
+}
+function plannedVideoOutputs(source, staticRoot, preset, probe) {
+  const dir = mirroredDir(source, staticRoot);
+  const name = posix2.basename(source, posix2.extname(source));
+  const width = outputWidth(probe.width, preset.maxWidth);
+  const outputs = [];
+  for (const codec of preset.codecs) {
+    outputs.push({
+      role: "video",
+      path: posix2.join(dir, name, `${name}-${width}.${codec}.mp4`),
+      codec,
+      width,
+      crf: preset.crf[codec],
+      speed: preset.speed[codec],
+      maxWidth: preset.maxWidth,
+      maxFps: preset.maxFps,
+      audio: preset.audio,
+      audioBitrate: preset.audioBitrate,
+      ...preset.search ? { search: { ...preset.search } } : {}
+    });
+  }
+  outputs.push({
+    role: "poster",
+    path: posix2.join(dir, name, `${name}-poster.avif`),
+    format: "avif",
+    width,
+    quality: preset.poster.quality,
+    effort: preset.poster.effort,
+    at: preset.poster.at
+  });
+  return outputs;
+}
+async function buildVideoItems(options) {
+  const staticRoot = options.staticRoot ?? ".";
+  const claimed = options.claimed ?? /* @__PURE__ */ new Set();
+  const items = [];
+  const files = options.files.map((file) => ({ file, source: toPosix(relative2(options.projectRoot, file)) })).sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+  const caps = options.engine ? await options.engine.capabilities() : null;
+  for (const { file, source } of files) {
+    if (source.startsWith("../") || source === "..") {
+      throw new BytecutError(
+        "SOURCE_OUTSIDE_PROJECT",
+        `${file} is outside the project root (${options.projectRoot}); run bytecut from a parent folder.`
+      );
+    }
+    const [info, sha] = await Promise.all([stat(file), sha256File(file)]);
+    if (!options.engine || !caps) {
+      items.push(skipped(source, info.size, sha, `needs ffmpeg: ${options.needsFfmpeg}`));
+      continue;
+    }
+    let probe;
+    try {
+      probe = options.probe ? await options.probe(file, sha) : await options.engine.probe(file);
+    } catch {
+      items.push(skipped(source, info.size, sha, "could not be read by ffprobe"));
+      continue;
+    }
+    if (!probe || probe.width === 0 || probe.height === 0) {
+      items.push(skipped(source, info.size, sha, "no video stream"));
+      continue;
+    }
+    const media = {
+      sourceWidth: probe.width,
+      sourceHeight: probe.height,
+      durationSec: probe.durationSec,
+      fps: probe.fps,
+      hasAudio: probe.hasAudio,
+      videoCodec: probe.videoCodec
+    };
+    const policy = options.policy ?? BUILTIN_POLICY;
+    const override = options.presetOverrides?.[source];
+    const forced = override ? getVideoPreset(override, policy.catalog) : void 0;
+    const matched = policy.assetFor(source);
+    const byAssets = matched ? getVideoPreset(matched.preset, policy.catalog) : void 0;
+    let preset;
+    let why;
+    if (forced) {
+      preset = forced;
+      why = { reason: `set to ${forced.name} for this file` };
+    } else if (byAssets && matched) {
+      preset = byAssets;
+      why = {
+        reason: `set to ${byAssets.name} by assets "${matched.pattern}"`,
+        confidence: "high"
+      };
+    } else if (posix2.extname(source).toLowerCase() === ".gif") {
+      preset = getVideoPreset("gif-to-video", policy.catalog);
+      why = { reason: "animated GIF", confidence: "high" };
+    } else {
+      const verdict = classifyVideo(source, probe);
+      preset = getVideoPreset(verdict.preset, policy.catalog);
+      why = { reason: verdict.reason, confidence: verdict.confidence };
+    }
+    const outputs = plannedVideoOutputs(source, staticRoot, preset, probe);
+    for (const out of outputs) {
+      if (claimed.has(out.path)) {
+        throw new BytecutError(
+          "OUTPUT_COLLISION",
+          `${source} would write ${out.path}, which another source already writes. Rename one of them.`
+        );
+      }
+      claimed.add(out.path);
+    }
+    items.push({
+      source,
+      sourceBytes: info.size,
+      sourceSha256: sha,
+      ...media,
+      preset: preset.name,
+      classification: why,
+      outputs
+    });
+  }
+  return items;
+}
+
+export {
+  classify,
+  sha256,
+  sha256File,
+  outputWidths,
+  mirroredDir,
+  DEFAULT_PUBLIC_PATH,
+  ANIMATED_GIF_REASON,
+  buildPlan,
+  classifyVideo,
+  plannedVideoOutputs,
+  buildVideoItems
+};

package/dist/cli.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+import {
+  collectDoctorReport,
+  formatDoctorReport
+} from "./chunk-PQRBLHCC.js";
+import {
+  svgoEngine
+} from "./chunk-LTWUPQDT.js";
+import {
+  audit
+} from "./chunk-4PWCQ4NF.js";
+import {
+  package_default
+} from "./chunk-AYYKUSRP.js";
+import {
+  formatAuditReport
+} from "./chunk-P5PFI3AO.js";
+import "./chunk-3DBJKHOD.js";
+import "./chunk-TCQFQ354.js";
+import {
+  sharpImageEngine
+} from "./chunk-CSFBJ3UH.js";
+import "./chunk-XUBQWBWH.js";
+import {
+  createVideoEngine,
+  discover,
+  ffmpegInstallText,
+  ffmpegStatus,
+  makeScorerFactory,
+  noAssetsMessage
+} from "./chunk-KN5QOB7R.js";
+import {
+  doctorDeps
+} from "./chunk-S3FQYUTI.js";
+import "./chunk-QOG2F4SF.js";
+import "./chunk-3PF6BBFK.js";
+import "./chunk-IZ4JEL3Q.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import "./chunk-FY53B4NB.js";
+
+// src/cli/index.ts
+import { defineCommand, runMain } from "citty";
+
+// src/cli/interactive.ts
+function isInteractive(env = process.env, stdin = process.stdin, stdout = process.stdout) {
+  const ci = env.CI;
+  const inCi = ci !== void 0 && ci !== "" && ci !== "0" && ci.toLowerCase() !== "false";
+  return Boolean(stdin.isTTY && stdout.isTTY) && !inCi;
+}
+async function runDefault() {
+  const found = await discover([]);
+  if (found.scanInputs.length === 0) {
+    console.error(noAssetsMessage("", found.project));
+    process.exitCode = 2;
+    return;
+  }
+  if (isInteractive()) {
+    const { runTui } = await import("./tui-CDF23I73.js");
+    await runTui({
+      projectRoot: found.projectRoot,
+      project: found.project,
+      config: found.config,
+      inputs: found.scanInputs,
+      outDir: found.outDir,
+      engine: sharpImageEngine,
+      svgEngine: svgoEngine,
+      toolVersion: package_default.version,
+      ffmpeg: ffmpegStatus(found.config),
+      videoEngine: createVideoEngine({}, found.config),
+      makeScorer: makeScorerFactory(void 0, found.config),
+      needsFfmpeg: ffmpegInstallText(),
+      loadDoctor: async () => formatDoctorReport(await collectDoctorReport(doctorDeps()))
+    });
+    return;
+  }
+  const report = await audit({
+    projectRoot: found.projectRoot,
+    engine: sharpImageEngine,
+    svgEngine: svgoEngine,
+    inputs: found.scanInputs,
+    outDir: found.outDir,
+    staticRoot: found.project.staticRoot,
+    ffmpeg: ffmpegStatus(found.config),
+    videoEngine: createVideoEngine({}, found.config),
+    needsFfmpeg: ffmpegInstallText(),
+    policy: found.config.policy,
+    exclude: found.config.exclude,
+    ignore: found.config.auditIgnore,
+    settings: found.config.rules,
+    budgets: found.config.budgets,
+    // A bare `npx bytecut` in CI should not create folders in the repo.
+    persistCache: false
+  });
+  console.log(formatAuditReport(report));
+  console.log(
+    "\nNot an interactive terminal. Run `bytecut optimize -y` to write the optimized files."
+  );
+}
+
+// src/cli/index.ts
+var SUBCOMMANDS = [
+  "audit",
+  "optimize",
+  "snippet",
+  "compare",
+  "explain",
+  "init",
+  "check",
+  "doctor"
+];
+var main = defineCommand({
+  meta: {
+    name: "bytecut",
+    version: package_default.version,
+    description: "Audit and optimize images and videos in web projects"
+  },
+  // Plain `bytecut` (no subcommand): interactive UI on a TTY, audit report otherwise.
+  // citty also invokes the parent's `run` after a subcommand finishes, so bail out then, or
+  // every subcommand would be followed by a second, unrelated audit of the project.
+  run: guarded(async ({ rawArgs }) => {
+    const first = rawArgs.find((arg) => !arg.startsWith("-"));
+    if (first !== void 0 && SUBCOMMANDS.includes(first)) return;
+    await runDefault();
+  }),
+  subCommands: {
+    audit: () => import("./audit-PEKVNXKA.js").then((m) => m.default),
+    optimize: () => import("./optimize-47YALM3D.js").then((m) => m.default),
+    snippet: () => import("./snippet-IIPVF6PS.js").then((m) => m.default),
+    compare: () => import("./compare-MPPGTUC5.js").then((m) => m.default),
+    explain: () => import("./explain-TS6XF5TX.js").then((m) => m.default),
+    init: () => import("./init-CWDWVJ55.js").then((m) => m.default),
+    check: () => import("./check-BYNAWCDE.js").then((m) => m.default),
+    doctor: () => import("./doctor-PWCUEBD5.js").then((m) => m.default)
+  }
+});
+await runMain(main);

package/dist/compare-MPPGTUC5.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import {
+  startCompareServer
+} from "./chunk-7DHE25UE.js";
+import {
+  MANIFEST_FILE,
+  parseManifest
+} from "./chunk-TCQFQ354.js";
+import {
+  configArg,
+  discover
+} from "./chunk-KN5QOB7R.js";
+import "./chunk-S3FQYUTI.js";
+import {
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import "./chunk-3PF6BBFK.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/compare.ts
+import { readFile } from "fs/promises";
+import { relative, resolve } from "path";
+import { defineCommand } from "citty";
+var compare_default = defineCommand({
+  meta: {
+    name: "compare",
+    description: "Serve a before/after page for one optimized file on localhost (127.0.0.1, random port)"
+  },
+  args: {
+    ...configArg,
+    port: { type: "string", description: "Port to listen on (default: a free one)" },
+    "out-dir": { type: "string", description: "Output folder (default: from the framework)" }
+  },
+  run: guarded(async ({ args }) => {
+    const inputs = args._.map(String);
+    if (inputs.length !== 1) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "Name one optimized file, e.g. `bytecut compare public/img/hero.jpg`."
+      );
+    }
+    let port = 0;
+    if (args.port !== void 0) {
+      port = Number(args.port);
+      if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new BytecutError("BAD_ARGUMENTS", `--port must be 0-65535, not "${args.port}".`);
+      }
+    }
+    const found = await discover([], args["out-dir"], args.config);
+    let text;
+    try {
+      text = await readFile(resolve(found.projectRoot, found.outDir, MANIFEST_FILE), "utf8");
+    } catch {
+      throw new BytecutError(
+        "INPUT_NOT_FOUND",
+        `No manifest at ${found.outDir}/${MANIFEST_FILE}. Run \`bytecut optimize -y\` first.`
+      );
+    }
+    const source = toPosix(relative(found.projectRoot, resolve(found.projectRoot, inputs[0])));
+    const server = await startCompareServer({
+      projectRoot: found.projectRoot,
+      outDir: found.outDir,
+      manifest: parseManifest(text),
+      source,
+      port
+    });
+    console.log(`Comparing ${source}`);
+    console.log(`  ${server.url}`);
+    console.log("Local only (127.0.0.1). Press Ctrl-C to stop.");
+    await new Promise((done) => {
+      process.once("SIGINT", () => done());
+      process.once("SIGTERM", () => done());
+    });
+    await server.close();
+  })
+});
+export {
+  compare_default as default
+};

package/dist/doctor-PWCUEBD5.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import {
+  collectDoctorReport,
+  formatDoctorReport
+} from "./chunk-PQRBLHCC.js";
+import {
+  doctorDeps
+} from "./chunk-S3FQYUTI.js";
+import {
+  resolveConfig
+} from "./chunk-3PF6BBFK.js";
+import {
+  isGitIgnored
+} from "./chunk-DJ45NQZD.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError,
+  detectProject,
+  loadConfig
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/doctor.ts
+import { defineCommand } from "citty";
+import { resolve } from "path";
+var doctor_default = defineCommand({
+  meta: {
+    name: "doctor",
+    description: "Check Node, sharp and ffmpeg, and report what is degraded"
+  },
+  args: {
+    config: {
+      type: "string",
+      description: "Path to a config file (default: bytecut.config.* in the project)"
+    },
+    ffmpeg: { type: "string", description: "Path to the ffmpeg binary" },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" },
+    ssimulacra2: {
+      type: "string",
+      description: "Path to a native ssimulacra2 (optional; a WebAssembly scorer is built in)"
+    },
+    json: { type: "boolean", description: "Print the report as JSON" }
+  },
+  run: guarded(async ({ args }) => {
+    const projectRoot = process.cwd();
+    let configError;
+    let resolved = await resolveConfig(projectRoot, null);
+    try {
+      resolved = await resolveConfig(projectRoot, await loadConfig(projectRoot, args.config));
+    } catch (error) {
+      if (!(error instanceof BytecutError)) throw error;
+      configError = error.message;
+      resolved = { ...resolved, project: await detectProject(projectRoot) };
+    }
+    const report = await collectDoctorReport(doctorDeps(), {
+      ffmpegFlag: args.ffmpeg,
+      ffprobeFlag: args.ffprobe,
+      ffmpegConfig: resolved.ffmpegPath,
+      ffprobeConfig: resolved.ffprobePath,
+      ssimulacra2Flag: args.ssimulacra2,
+      ssimulacra2Config: resolved.ssimulacra2Path
+    });
+    report.project = {
+      framework: resolved.project.framework,
+      configFile: resolved.loaded?.name ?? null,
+      ...configError ? { configError } : {},
+      outDir: resolved.project.outDir,
+      outDirIgnored: await isGitIgnored(projectRoot, resolve(projectRoot, resolved.project.outDir))
+    };
+    console.log(args.json ? JSON.stringify(report, null, 2) : formatDoctorReport(report));
+    if (!report.ok) process.exitCode = 1;
+  })
+});
+export {
+  doctor_default as default
+};