bytecut 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 anupjon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,141 @@
-# Temporary Holding Version
+# bytecut
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Audit and optimize the images and videos in a web project, from the terminal.
+
+```sh
+npx bytecut
+```
+
+With no configuration, bytecut detects your framework (Next.js, Astro, Vite or a static
+site), scans the asset folders, shows what is too heavy and how much you would save, and
+optimizes on Enter. Your original files are never modified: outputs go to a separate folder
+that mirrors your source tree, and that folder is meant to be committed.
+
+## What you get
+
+By default each image becomes **one JPEG**, with the longest side capped at 1920 px (a
+landscape image is 1920 wide, a portrait one is 1920 tall, nothing is ever upscaled). Metadata
+and GPS are stripped, orientation is applied and the colour profile is kept.
+
+```
+public/img/hero.jpg  →  public/_bytecut/img/hero/hero-1920.jpg
+                         public/_bytecut/bytecut-manifest.json
+```
+
+- **Transparency is preserved.** A source that really uses alpha gets a lossless PNG instead of
+  a JPEG, and so does flat art such as icons and logos.
+- **WebP and AVIF are opt-in** (see [Configuration](#configuration)).
+- **A file is only written if it is smaller** than the source; otherwise it is reported as
+  "already optimal".
+- **Videos and animated GIFs** become AV1 and H.264 MP4 plus a poster, using your own
+  `ffmpeg` (see [Video](#video)).
+
+Re-running is cheap: unchanged sources are skipped by content hash, and the manifest is
+byte-identical when nothing changed, so it diffs cleanly in pull requests.
+
+## Commands
+
+| Command                       | What it does                                                              |
+| ----------------------------- | ------------------------------------------------------------------------- |
+| `bytecut`                     | Interactive session on a TTY; prints the audit elsewhere                  |
+| `bytecut audit`               | Report what is too heavy, with estimated savings                          |
+| `bytecut optimize [paths] -y` | Write optimized files. Without `-y` it prints the plan and writes nothing |
+| `bytecut snippet <file>`      | Print the `<picture>` / `<video>` markup (HTML or JSX) for a file         |
+| `bytecut compare <file>`      | Serve a before/after page on `127.0.0.1` (random port, private path)      |
+| `bytecut explain <file>`      | Show which rule chose a file's preset and what it resolves to             |
+| `bytecut init`                | Write a minimal `bytecut.config.json` with only non-default choices       |
+| `bytecut check`               | CI mode: exit 1 if a finding is an error, 2 if it could not run           |
+| `bytecut doctor`              | Report Node, sharp, ffmpeg, the scorer, and what is degraded              |
+
+Useful flags: `--dry-run --json` prints the plan as JSON and `--plan <file>` executes a saved
+one; `--out-dir`, `--preset`, `--force`, `--placeholder dominant-color|lqip|blurhash|none`.
+
+In the interactive session: `space` toggles a file, `enter` reviews and runs, `p` changes the
+preset, `o` the output folder, `d` details, `esc` cancels, `?` help. Type `/` for commands
+(`/snippet @file`, `/compare @file`, `/save`) and `@` to mention a file.
+
+## Configuration
+
+Everything is optional. Config is only needed to make a choice stick. Put it in
+`bytecut.config.json` (or `.ts`, `.mjs`, `.toml`); unknown keys are errors.
+
+```json
+{
+  "presets": {
+    "photo": { "formats": ["jpg", "webp", "avif"] },
+    "gallery": {
+      "extends": "photo",
+      "maxEdge": 1280,
+      "ssimulacra2": 80,
+      "maxSize": "150 KB",
+      "floor": 65
+    },
+    "loop": { "extends": "background-video", "vmaf": 92 }
+  },
+  "assets": { "public/gallery/**": "gallery", "public/loops/*.mp4": "loop" },
+  "budgets": { "maxFileSize": "250 KB", "maxTotalSize": "5 MB" }
+}
+```
+
+- **Presets**: built-in `photo`, `hero`, `icon`, `background-video`, `content-video` and
+  `gif-to-video`. Add your own with `extends`; the first matching `assets` glob wins.
+- **Size**: `maxEdge` caps the longest side; `widths` lists widths instead (a responsive set).
+- **Formats**: `jpg` (default), `png`, `webp`, `avif`. A `<picture>` lists AVIF, then WebP, and
+  the JPEG is the `<img>`.
+- **Quality**: `target` (`low`, `balanced`, `high`, `lossless`), or `quality` per format.
+- **Perceptual targets**: see below.
+
+## Quality targets
+
+Instead of a fixed quality you can ask for a score. bytecut then finds the **smallest** output
+that still meets it:
+
+- `ssimulacra2: 80` (images and video) searches quality on a representative crop, then
+  confirms on the full-size output.
+- `maxSize` with a required `floor` lowers quality, then steps the width down, to fit a size
+  cap. A constraint that cannot be met writes nothing and fails the run; it is never silently
+  exceeded.
+- `vmaf: 92` (video) uses ffmpeg's `libvmaf`. Without it, the preset's fixed quality is used
+  and a warning says so.
+
+SSIMULACRA2 runs as WebAssembly in worker threads, so no native binary is needed. A native
+`ssimulacra2` is used if one is found (`--ssimulacra2`, `BYTECUT_SSIMULACRA2`,
+`ssimulacra2Path`, or `PATH`), as a speed-up only.
+
+## Video
+
+bytecut uses **your own** `ffmpeg` and `ffprobe` (`--ffmpeg`, `BYTECUT_FFMPEG`, `ffmpegPath`, or
+`PATH`). It never downloads or bundles one. Without ffmpeg images work fully and videos are
+listed as "needs ffmpeg" with the install command for your OS. Without an AV1 encoder you still
+get the H.264 file and the poster. `bytecut doctor` shows exactly what is available.
+
+## CI
+
+```sh
+npx bytecut check                       # exit 1 on an error finding
+npx bytecut check --fail-on warn        # stricter
+npx bytecut check --changed origin/main # only files changed since a ref
+npx bytecut check --report md           # a Markdown report for a PR comment
+```
+
+`project/over-budget` is an error by default; other rules are promoted or silenced under
+`audit.rules`.
+
+## Guarantees
+
+- Sources are read-only. bytecut only writes inside the output folder (and the config file,
+  and only when you ask it to), atomically, so a cancelled run never leaves a half-written
+  file.
+- It only deletes files listed in its manifest, and never without confirmation or an explicit flag.
+- No network access at runtime: no telemetry, no update checks, no downloads.
+- Same input, same settings and same tool versions give the same bytes where the encoder allows.
+
+## Requirements
+
+Node.js 22 or newer. Images use [sharp](https://sharp.pixelplumbing.com). Developed and tested
+on Linux; macOS and Windows have not been verified yet.
+
+## Licence
+
+MIT. The bundled SSIMULACRA2 build (`bytecut-ssimulacra2`) is a WebAssembly compilation of
+[rust-av/ssimulacra2](https://github.com/rust-av/ssimulacra2) and is BSD-2-Clause.

package/dist/audit-PEKVNXKA.js

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import {
+  svgoEngine
+} from "./chunk-LTWUPQDT.js";
+import {
+  audit
+} from "./chunk-4PWCQ4NF.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 {
+  configArg,
+  createVideoEngine,
+  discover,
+  ffmpegInstallText,
+  ffmpegStatus,
+  noAssetsMessage
+} from "./chunk-KN5QOB7R.js";
+import "./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/commands/audit.ts
+import { defineCommand } from "citty";
+var audit_default = defineCommand({
+  meta: {
+    name: "audit",
+    description: "Report what is too heavy in your image assets, with estimated savings"
+  },
+  args: {
+    ...configArg,
+    json: { type: "boolean", description: "Print the report as JSON" },
+    all: { type: "boolean", description: "Show every finding instead of the first 10 per rule" },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    ffmpeg: {
+      type: "string",
+      description: "Path to the ffmpeg binary (else BYTECUT_FFMPEG, then PATH)"
+    },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" },
+    cache: {
+      type: "boolean",
+      default: true,
+      description: "Keep the analysis cache in <outDir>/.bytecut-cache (--no-cache to avoid writing)"
+    }
+  },
+  run: guarded(async ({ args }) => {
+    const found = await discover(args._.map(String), args["out-dir"], args.config);
+    const { config } = found;
+    if (found.scanInputs.length === 0) {
+      console.error(noAssetsMessage("audit", found.project));
+      process.exitCode = 2;
+      return;
+    }
+    const report = await audit({
+      projectRoot: found.projectRoot,
+      engine: sharpImageEngine,
+      svgEngine: svgoEngine,
+      inputs: found.scanInputs,
+      outDir: found.outDir,
+      staticRoot: found.project.staticRoot,
+      ffmpeg: ffmpegStatus(config),
+      videoEngine: createVideoEngine({ ffmpeg: args.ffmpeg, ffprobe: args.ffprobe }, config),
+      policy: config.policy,
+      exclude: config.exclude,
+      ignore: config.auditIgnore,
+      settings: config.rules,
+      budgets: config.budgets,
+      needsFfmpeg: ffmpegInstallText(),
+      persistCache: args.cache !== false
+    });
+    if (args.json) {
+      process.stdout.write(
+        `${JSON.stringify({ version: 1, project: found.project, ...report }, null, 2)}
+`
+      );
+      return;
+    }
+    console.log(formatAuditReport(report, { all: Boolean(args.all) }));
+  })
+});
+export {
+  audit_default as default
+};

package/dist/check-BYNAWCDE.js

@@ -0,0 +1,348 @@
+#!/usr/bin/env node
+import {
+  svgoEngine
+} from "./chunk-LTWUPQDT.js";
+import {
+  audit
+} from "./chunk-4PWCQ4NF.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 {
+  configArg,
+  createVideoEngine,
+  discover,
+  ffmpegInstallText,
+  ffmpegStatus,
+  noAssetsMessage
+} from "./chunk-KN5QOB7R.js";
+import {
+  run
+} from "./chunk-S3FQYUTI.js";
+import {
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import "./chunk-3PF6BBFK.js";
+import "./chunk-IZ4JEL3Q.js";
+import {
+  BytecutError,
+  CONFIG_FILES,
+  formatBytes,
+  percentChange,
+  plural
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/check.ts
+import { defineCommand } from "citty";
+
+// src/core/commands/check.ts
+function evaluate(report, options = {}) {
+  const failOn = options.failOn ?? "error";
+  const changed = options.changed ?? null;
+  const inScope = (f) => !changed || changed.all || f.source === void 0 || changed.files.has(f.source);
+  const findings = report.findings.filter(inScope);
+  const failing = findings.filter(
+    (f) => f.severity === "error" || failOn === "warn" && f.severity === "warn"
+  );
+  const count = (s) => findings.filter((f) => f.severity === s).length;
+  return {
+    ok: failing.length === 0,
+    failOn,
+    findings,
+    failing,
+    counts: { error: count("error"), warn: count("warn"), info: count("info") },
+    scope: changed ? {
+      base: changed.base,
+      changedFiles: changed.files.size,
+      everything: changed.all,
+      dropped: report.findings.length - findings.length
+    } : null
+  };
+}
+
+// src/core/git/changed.ts
+var fail = (message, cause) => new BytecutError("GIT_UNAVAILABLE", message, cause ? { cause } : void 0);
+function nulList(stdout) {
+  return stdout.split("\0").filter((p) => p.length > 0);
+}
+async function changedFiles(options) {
+  const { projectRoot, base, run: run2 } = options;
+  const git = async (...args) => {
+    const { stdout } = await run2("git", ["-C", projectRoot, ...args]);
+    return stdout;
+  };
+  if (base.startsWith("-")) throw fail(`"${base}" is not a git ref.`);
+  try {
+    await git("rev-parse", "--is-inside-work-tree");
+  } catch (error) {
+    const missing = error.code === "ENOENT";
+    throw fail(
+      missing ? "--changed needs git, which was not found on PATH." : "--changed needs a git repository; this folder is not inside one.",
+      error
+    );
+  }
+  let mergeBase;
+  try {
+    await git("rev-parse", "--verify", "--quiet", `${base}^{commit}`);
+  } catch (error) {
+    const shallow = (await git("rev-parse", "--is-shallow-repository").catch(() => "")).trim();
+    throw fail(
+      `The ref "${base}" is not in this repository.` + (shallow === "true" ? " This is a shallow clone: fetch more history first (for GitHub Actions, `fetch-depth: 0` on actions/checkout)." : " bytecut never fetches; fetch it yourself if it is a remote branch."),
+      error
+    );
+  }
+  try {
+    mergeBase = (await git("merge-base", base, "HEAD")).trim();
+  } catch (error) {
+    throw fail(
+      `No common ancestor between "${base}" and HEAD. In a shallow clone, fetch more history (for GitHub Actions, \`fetch-depth: 0\`).`,
+      error
+    );
+  }
+  const tracked = nulList(
+    await git(
+      "diff",
+      "--name-only",
+      "--relative",
+      "--diff-filter=ACMRT",
+      "-z",
+      mergeBase,
+      "--",
+      "."
+    )
+  );
+  const untracked = nulList(
+    await git("ls-files", "--others", "--exclude-standard", "-z", "--", ".")
+  );
+  const files = new Set([...tracked, ...untracked].map(toPosix));
+  const configNames = new Set(CONFIG_FILES);
+  const all = [...files].some((f) => configNames.has(f));
+  return { base, files, all };
+}
+
+// src/core/report/json.ts
+function renderJsonReport(report, verdict) {
+  return `${JSON.stringify(
+    {
+      version: 1,
+      ok: verdict.ok,
+      failOn: verdict.failOn,
+      counts: verdict.counts,
+      changed: verdict.scope,
+      findings: verdict.findings,
+      failing: verdict.failing.length,
+      scanned: report.counts,
+      totals: report.totals,
+      unprobed: report.unprobed,
+      notes: report.notes
+    },
+    null,
+    2
+  )}
+`;
+}
+
+// src/core/report/markdown.ts
+var MARKDOWN_LIMIT = 6e4;
+var ROWS_PER_RULE = 20;
+var SEVERITY_ORDER = { error: 0, warn: 1, info: 2 };
+function cell(text) {
+  return text.replace(/\\/g, "\\\\").replace(/\|/g, "\\|").replace(/[`*_<>[\]]/g, (c) => `\\${c}`).replace(/\r?\n/g, " ");
+}
+function size(f) {
+  if (f.current !== void 0 && f.estimated !== void 0) {
+    return `${formatBytes(f.current)} \u2192 ~${formatBytes(f.estimated)} (${percentChange(f.current, f.estimated)})`;
+  }
+  return f.current !== void 0 ? formatBytes(f.current) : "";
+}
+function renderMarkdownReport(report, verdict) {
+  const out = [];
+  const { counts, scope } = verdict;
+  out.push(`## bytecut check: ${verdict.ok ? "passed" : "failed"}`, "");
+  const summary = [
+    `${plural(counts.error, "error")}, ${plural(counts.warn, "warning")}, ${counts.info} info`
+  ];
+  const c = report.counts;
+  summary.push(
+    `scanned ${plural(c.images + c.skipped, "image")}, ${plural(c.svgs, "SVG")}, ${plural(c.videos, "video")} (${formatBytes(report.totals.sourceBytes)})`
+  );
+  if (scope) {
+    summary.push(
+      scope.everything ? `a bytecut config changed since \`${cell(scope.base)}\`, so every file is in scope` : `${plural(scope.changedFiles, "file")} changed since \`${cell(scope.base)}\``
+    );
+  }
+  out.push(summary.join(" \xB7 "), "");
+  if (!verdict.ok) {
+    out.push(
+      `Failing on ${verdict.failOn === "warn" ? "warnings and errors" : "errors"}: ${plural(verdict.failing.length, "finding")}.`,
+      ""
+    );
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const f of verdict.findings) groups.set(f.ruleId, [...groups.get(f.ruleId) ?? [], f]);
+  const ordered = [...groups.entries()].sort(([ia, a], [ib, b]) => {
+    const d = (SEVERITY_ORDER[a[0].severity] ?? 9) - (SEVERITY_ORDER[b[0].severity] ?? 9);
+    return d || (ia < ib ? -1 : 1);
+  });
+  const tail = [];
+  if (report.unprobed.length > 0) {
+    tail.push(
+      `> ${plural(report.unprobed.length, "video")} not analysed because ffmpeg was not found.`
+    );
+  }
+  for (const note of report.notes) tail.push(`> ${cell(note)}`);
+  let omitted = 0;
+  for (const [ruleId, findings] of ordered) {
+    const section = [
+      `### \`${ruleId}\` \xB7 ${findings[0].severity} \xB7 ${plural(findings.length, "file")}`,
+      "",
+      "| File | Size | Detail |",
+      "| --- | --- | --- |"
+    ];
+    for (const f of findings.slice(0, ROWS_PER_RULE)) {
+      const where = f.path ? `${f.source ?? ""} \u2192 ${f.path}` : f.source ?? "(project)";
+      section.push(`| ${cell(where)} | ${cell(size(f))} | ${cell(f.message)} |`);
+    }
+    if (findings.length > ROWS_PER_RULE) {
+      section.push("", `\u2026 and ${findings.length - ROWS_PER_RULE} more.`);
+    }
+    section.push("");
+    const text = section.join("\n");
+    if (out.join("\n").length + text.length + tail.join("\n").length + 200 > MARKDOWN_LIMIT) {
+      omitted += findings.length;
+      continue;
+    }
+    out.push(text);
+  }
+  if (omitted > 0) {
+    out.push(
+      `_${plural(omitted, "more finding")} not shown: this comment hit its size limit. Run \`bytecut check\` locally for the full list._`,
+      ""
+    );
+  }
+  out.push(...tail);
+  return `${out.join("\n").trimEnd()}
+`;
+}
+
+// src/cli/commands/check.ts
+var EXIT = { ok: 0, failed: 1, unusable: 2 };
+var REPORTS = ["md", "json"];
+var FAIL_ON = ["error", "warn"];
+var check_default = defineCommand({
+  meta: {
+    name: "check",
+    description: "CI mode: audit the project and exit non-zero if any finding is an error"
+  },
+  args: {
+    ...configArg,
+    // Declared boolean so a bare `--changed` never swallows the flag after it; the base ref
+    // is read from the raw arguments below.
+    changed: {
+      type: "boolean",
+      description: "Only report files changed since a git ref: --changed (HEAD, i.e. local changes), --changed origin/main or --changed=origin/main"
+    },
+    report: { type: "string", description: "Print a report on stdout: md or json" },
+    "fail-on": {
+      type: "string",
+      description: "Lowest severity that fails the check: error (default) or warn"
+    },
+    all: { type: "boolean", description: "Text report: every finding, not the first 10 per rule" },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    ffmpeg: { type: "string", description: "Path to the ffmpeg binary" },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" }
+  },
+  run: async ({ args, rawArgs }) => {
+    try {
+      process.exitCode = await check(args, rawArgs);
+    } catch (error) {
+      if (!(error instanceof BytecutError)) throw error;
+      console.error(`bytecut: ${error.message} [${error.code}]`);
+      process.exitCode = EXIT.unusable;
+    }
+  }
+});
+async function check(args, rawArgs) {
+  const report = args.report;
+  if (report !== void 0 && !REPORTS.includes(report)) {
+    throw new BytecutError("BAD_ARGUMENTS", `--report must be md or json, not "${report}".`);
+  }
+  const failOn = args["fail-on"] ?? "error";
+  if (!FAIL_ON.includes(failOn)) {
+    throw new BytecutError("BAD_ARGUMENTS", `--fail-on must be error or warn, not "${failOn}".`);
+  }
+  let changedBase = null;
+  const positional = args._.map(String);
+  const at = rawArgs.findIndex((a) => a === "--changed" || a.startsWith("--changed="));
+  if (at !== -1) {
+    const arg = rawArgs[at];
+    const next = rawArgs[at + 1];
+    if (arg.includes("=")) changedBase = arg.slice(arg.indexOf("=") + 1) || "HEAD";
+    else if (next !== void 0 && !next.startsWith("-")) {
+      changedBase = next;
+      const i = positional.indexOf(next);
+      if (i !== -1) positional.splice(i, 1);
+    } else changedBase = "HEAD";
+  }
+  const found = await discover(
+    positional,
+    args["out-dir"],
+    args.config
+  );
+  if (found.scanInputs.length === 0) {
+    console.error(noAssetsMessage("check", found.project));
+    return EXIT.unusable;
+  }
+  const { config } = found;
+  const changed = changedBase === null ? null : await changedFiles({ projectRoot: found.projectRoot, base: changedBase, run });
+  const result = await audit({
+    projectRoot: found.projectRoot,
+    engine: sharpImageEngine,
+    svgEngine: svgoEngine,
+    inputs: found.scanInputs,
+    outDir: found.outDir,
+    staticRoot: found.project.staticRoot,
+    ffmpeg: ffmpegStatus(config),
+    videoEngine: createVideoEngine(
+      { ffmpeg: args.ffmpeg, ffprobe: args.ffprobe },
+      config
+    ),
+    needsFfmpeg: ffmpegInstallText(),
+    persistCache: false,
+    policy: config.policy,
+    exclude: config.exclude,
+    ignore: config.auditIgnore,
+    settings: config.rules,
+    budgets: config.budgets
+  });
+  const verdict = evaluate(result, { failOn, changed });
+  if (report === "json") process.stdout.write(renderJsonReport(result, verdict));
+  else if (report === "md") process.stdout.write(renderMarkdownReport(result, verdict));
+  else {
+    const view = { ...result, findings: verdict.findings };
+    console.log(formatAuditReport(view, { all: Boolean(args.all) }));
+    if (verdict.scope) {
+      console.log(
+        verdict.scope.everything ? `A bytecut config changed since ${verdict.scope.base}: every file is in scope.` : `${plural(verdict.scope.changedFiles, "file")} changed since ${verdict.scope.base}; findings about other files are not shown (${verdict.scope.dropped} hidden).`
+      );
+    }
+  }
+  const summary = `${plural(verdict.counts.error, "error")}, ${plural(verdict.counts.warn, "warning")}`;
+  console.error(
+    verdict.ok ? `bytecut check: passed (${summary}).` : `bytecut check: failed (${plural(verdict.failing.length, "failing finding")}; ${summary}).`
+  );
+  return verdict.ok ? EXIT.ok : EXIT.failed;
+}
+export {
+  EXIT,
+  check_default as default
+};