bytecut 0.0.0-stage → 0.1.0

package/dist/chunk-4PWCQ4NF.js

@@ -0,0 +1,620 @@
+#!/usr/bin/env node
+import {
+  AnalysisCache,
+  collectAssets,
+  engineFingerprint,
+  sortFindings,
+  walkFiles,
+  withVideos
+} from "./chunk-P5PFI3AO.js";
+import {
+  MANIFEST_FILE,
+  parseManifest
+} from "./chunk-TCQFQ354.js";
+import {
+  ANIMATED_GIF_REASON,
+  buildPlan,
+  classify,
+  classifyVideo,
+  sha256
+} from "./chunk-XUBQWBWH.js";
+import {
+  isFastStart,
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import {
+  BUILTIN_POLICY,
+  getImagePreset,
+  pickAv1Encoder,
+  rootPreset
+} from "./chunk-3PF6BBFK.js";
+import {
+  SafeFs
+} from "./chunk-IZ4JEL3Q.js";
+import {
+  ALL_RULES,
+  checkCache,
+  checkVideoCache,
+  matchesGlob,
+  savingOf
+} from "./chunk-FY53B4NB.js";
+
+// src/core/commands/audit.ts
+import { stat as stat2 } from "fs/promises";
+import { resolve } from "path";
+
+// src/core/audit/estimate.ts
+var TRIAL_MAX_WIDTH = 640;
+var SIZE_EXPONENT = 1.6;
+function estimateKey(sha2562, preset, out, width, encoder) {
+  return [
+    sha2562,
+    preset,
+    out.format,
+    width,
+    out.lossless ? "L" : `q${out.quality}`,
+    out.effort,
+    encoder
+  ].join("|");
+}
+async function estimateItem(item, readData, deps) {
+  if (item.skip || item.outputs.length === 0) return null;
+  const encoders = deps.engine.encoders();
+  const perFormat = [];
+  const formats = [...new Set(item.outputs.map((o) => o.format))];
+  for (const format of formats) {
+    const outs = item.outputs.filter((o) => o.format === format).sort((a, b) => a.width - b.width);
+    const largest = outs[outs.length - 1];
+    const within = outs.filter((o) => o.width <= TRIAL_MAX_WIDTH);
+    const trial = within.length > 0 ? within[within.length - 1] : { ...outs[0], width: TRIAL_MAX_WIDTH };
+    const key = estimateKey(
+      item.sourceSha256,
+      item.preset,
+      trial,
+      trial.width,
+      encoders[format] ?? format
+    );
+    let bytes = deps.cache.getEstimate(key)?.bytes;
+    if (bytes === void 0) {
+      const encoded = await deps.engine.encode(await readData(), trial);
+      bytes = encoded.data.byteLength;
+      deps.cache.setEstimate(key, { bytes, basis: "exact" });
+    }
+    const exact = trial.width === largest.width;
+    perFormat.push({
+      format,
+      width: largest.width,
+      bytes: exact ? bytes : Math.round(bytes * (largest.width / trial.width) ** SIZE_EXPONENT),
+      basis: exact ? "exact" : "extrapolated"
+    });
+  }
+  const best = perFormat.reduce((a, b) => b.bytes < a.bytes ? b : a);
+  return { best, perFormat };
+}
+
+// src/core/scan/references.ts
+import { readFile, stat } from "fs/promises";
+import { basename, extname } from "path";
+var TEXT_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".html",
+  ".htm",
+  ".css",
+  ".scss",
+  ".sass",
+  ".less",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".ts",
+  ".tsx",
+  ".mts",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".md",
+  ".mdx",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".xml",
+  ".php",
+  ".twig",
+  ".liquid",
+  ".njk",
+  ".ejs",
+  ".hbs",
+  ".erb",
+  ".txt"
+]);
+var SKIPPED_NAMES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb"]);
+var MAX_FILE_BYTES = 1024 * 1024;
+var MAX_TOTAL_BYTES = 64 * 1024 * 1024;
+var IMAGE_REFERENCE = /[\w@%+~.\-/\\]+\.(?:jpe?g|png|webp|avif|gif|svg)\b/gi;
+async function scanReferences(options) {
+  const names = /* @__PURE__ */ new Set();
+  let filesScanned = 0;
+  let total = 0;
+  let truncated = false;
+  await walkFiles(options.cwd, options, async (path) => {
+    if (truncated) return;
+    if (!TEXT_EXTENSIONS.has(extname(path).toLowerCase()) || SKIPPED_NAMES.has(basename(path))) {
+      return;
+    }
+    const info = await stat(path).catch(() => null);
+    if (!info || info.size > MAX_FILE_BYTES) return;
+    if (total + info.size > MAX_TOTAL_BYTES) {
+      truncated = true;
+      return;
+    }
+    total += info.size;
+    let text;
+    try {
+      text = await readFile(path, "utf8");
+    } catch {
+      return;
+    }
+    filesScanned++;
+    for (const match of text.matchAll(IMAGE_REFERENCE)) {
+      let name = match[0].split(/[\\/]/).pop().toLowerCase();
+      try {
+        name = decodeURIComponent(name);
+      } catch {
+      }
+      names.add(name);
+    }
+  });
+  return { names, filesScanned, truncated };
+}
+
+// src/core/commands/audit.ts
+import { relative } from "path";
+
+// src/core/audit/estimate-video.ts
+var EXACT_MAX_SECONDS = 4;
+var SAMPLE_SECONDS = 1.5;
+var SAMPLE_POINTS = [0.2, 0.5, 0.8];
+function encoderFor(codec, caps) {
+  return codec === "h264" ? caps.libx264 ? "libx264" : null : pickAv1Encoder(caps);
+}
+var probeOf = (item) => ({
+  durationSec: item.durationSec,
+  width: item.sourceWidth,
+  height: item.sourceHeight,
+  fps: item.fps,
+  videoCodec: item.videoCodec,
+  pixelFormat: null,
+  bitrate: null,
+  hasAudio: item.hasAudio,
+  audioCodec: null,
+  container: "unknown"
+});
+function sampleStarts(durationSec) {
+  if (durationSec <= EXACT_MAX_SECONDS) return [{ startSec: 0, durationSec }];
+  return SAMPLE_POINTS.map((p) => ({
+    startSec: Math.max(
+      0,
+      Math.min(durationSec - SAMPLE_SECONDS, durationSec * p - SAMPLE_SECONDS / 2)
+    ),
+    durationSec: SAMPLE_SECONDS
+  }));
+}
+function audioBytes(out, item) {
+  if (out.audio !== "keep" || !item.hasAudio) return 0;
+  const kbps = Number(out.audioBitrate.replace(/k$/, ""));
+  return Math.round(kbps * 1e3 * item.durationSec / 8);
+}
+async function estimateVideo(item, deps, sourcePath) {
+  if (item.skip) return null;
+  const caps = await deps.engine.capabilities();
+  if (!caps) return null;
+  const probe = probeOf(item);
+  const starts = sampleStarts(item.durationSec);
+  const exact = starts.length === 1 && starts[0].durationSec >= item.durationSec;
+  const perCodec = [];
+  for (const out of item.outputs) {
+    if (out.role !== "video") continue;
+    const encoder = encoderFor(out.codec, caps);
+    if (!encoder) continue;
+    const key = [
+      "video",
+      item.sourceSha256,
+      out.codec,
+      encoder,
+      out.crf,
+      out.speed,
+      out.maxWidth ?? "-",
+      out.maxFps ?? "-",
+      deps.ffmpegVersion,
+      exact ? "exact" : "sampled"
+    ].join("|");
+    let streamBytes = deps.cache.getEstimate(key)?.bytes;
+    if (streamBytes === void 0) {
+      let total = 0;
+      let seconds = 0;
+      for (const s of starts) {
+        total += await deps.engine.sampleBytes(
+          {
+            source: sourcePath,
+            encoder,
+            crf: out.crf,
+            speed: out.speed,
+            maxWidth: out.maxWidth,
+            maxFps: out.maxFps,
+            startSec: s.startSec,
+            durationSec: s.durationSec,
+            probe
+          },
+          deps.signal
+        );
+        seconds += s.durationSec;
+      }
+      streamBytes = Math.round(seconds > 0 ? total / seconds * item.durationSec : total);
+      deps.cache.setEstimate(key, { bytes: streamBytes, basis: exact ? "exact" : "extrapolated" });
+    }
+    perCodec.push({
+      codec: out.codec,
+      bytes: streamBytes + audioBytes(out, item),
+      basis: exact ? "exact" : "extrapolated"
+    });
+  }
+  if (perCodec.length === 0) return null;
+  const best = perCodec.reduce((a, b) => b.bytes < a.bytes ? b : a);
+  return { best, perCodec };
+}
+
+// src/core/commands/audit.ts
+import { basename as basename2, dirname, extname as extname2 } from "path";
+async function audit(options) {
+  const { projectRoot, engine, svgEngine } = options;
+  const outDir = resolve(projectRoot, options.outDir);
+  const notes = [];
+  const found = await collectAssets(options.inputs, {
+    cwd: projectRoot,
+    outDir,
+    ...options.exclude ? { exclude: options.exclude } : {}
+  });
+  const policy = options.policy ?? BUILTIN_POLICY;
+  const fs = await SafeFs.create({
+    projectRoot,
+    outDir,
+    sourceFiles: [...found.files, ...found.svgs, ...found.videos],
+    sourceDirs: found.sourceDirs
+  });
+  const videoVersions = options.videoEngine ? await options.videoEngine.versions() : {};
+  const cache = await AnalysisCache.load(
+    fs,
+    `${engineFingerprint(engine, videoVersions)};${svgEngine.version()}`
+  );
+  const manifestData = await fs.readOutput(MANIFEST_FILE);
+  const manifest = manifestData ? parseManifest(manifestData.toString("utf8")) : null;
+  const total = found.files.length + found.videos.length;
+  let analyzed = 0;
+  options.onProgress?.({ phase: "scan", done: 0, total });
+  const analyze = async (data, digest) => {
+    let result = cache.getAnalysis(digest);
+    if (!result) {
+      result = await engine.analyze(data);
+      cache.setAnalysis(digest, result);
+    }
+    options.onProgress?.({ phase: "analyze", done: ++analyzed, total });
+    return result;
+  };
+  const imagePlan = await buildPlan({
+    files: found.files,
+    projectRoot,
+    outDir,
+    staticRoot: options.staticRoot,
+    choosePreset: (source, analysis) => {
+      const forced = options.presetOverrides?.[source];
+      if (forced) {
+        return {
+          preset: getImagePreset(forced, policy.catalog),
+          reason: `set to ${forced} for this file`
+        };
+      }
+      const matched = policy.assetFor(source);
+      const assetPreset = matched ? policy.catalog.image[matched.preset] : void 0;
+      if (matched && assetPreset) {
+        return {
+          preset: assetPreset,
+          reason: `set to ${matched.preset} by assets "${matched.pattern}"`,
+          confidence: "high"
+        };
+      }
+      const verdict = classify(source, analysis);
+      return {
+        preset: getImagePreset(verdict.preset, policy.catalog),
+        reason: verdict.reason,
+        confidence: verdict.confidence
+      };
+    },
+    engine,
+    analyze,
+    readSource: (path) => fs.readSource(path)
+  });
+  const needsFfmpeg = options.needsFfmpeg ?? "install ffmpeg";
+  const plan = await withVideos(imagePlan, {
+    projectRoot,
+    staticRoot: options.staticRoot,
+    videoFiles: found.videos,
+    videoEngine: options.videoEngine ?? null,
+    needsFfmpeg,
+    presetOverrides: options.presetOverrides,
+    policy,
+    cache
+  });
+  const outputHash = async (path) => {
+    const data = await fs.readOutput(path);
+    return data ? sha256(data) : null;
+  };
+  const absoluteOf = (source) => resolve(projectRoot, ...source.split("/"));
+  const images = [];
+  const skipped = [];
+  let estimated = 0;
+  for (const item of plan.items) {
+    options.onProgress?.({ phase: "estimate", done: estimated++, total });
+    if (item.skip) {
+      skipped.push({
+        source: item.source,
+        bytes: item.sourceBytes,
+        reason: item.skip.reason,
+        animatedGif: item.skip.reason.startsWith(ANIMATED_GIF_REASON)
+      });
+      continue;
+    }
+    const data = absoluteOf(item.source);
+    const estimate = await estimateItem(item, () => fs.readSource(data), { engine, cache });
+    images.push({
+      source: item.source,
+      bytes: item.sourceBytes,
+      sha256: item.sourceSha256,
+      // The analysis is cached by hash, so this is a lookup, not a second decode.
+      analysis: cache.getAnalysis(item.sourceSha256),
+      classification: {
+        // Rules reason about the built-in a custom preset descends from.
+        preset: rootPreset(policy.catalog, item.preset),
+        confidence: item.classification?.confidence ?? "low",
+        reason: item.classification?.reason ?? ""
+      },
+      item,
+      cache: await checkCache(item, manifest?.sources[item.source], outputHash),
+      estimate
+    });
+  }
+  const svgs = [];
+  for (const path of found.svgs) {
+    const buffer = await fs.readSource(path);
+    const digest = sha256(buffer);
+    let analysis = cache.getSvg(digest);
+    if (!analysis) {
+      analysis = svgEngine.analyze(buffer.toString("utf8"));
+      cache.setSvg(digest, analysis);
+    }
+    svgs.push({
+      source: toPosix(relative(projectRoot, path)),
+      bytes: buffer.byteLength,
+      sha256: digest,
+      ...analysis
+    });
+  }
+  svgs.sort((a, b) => a.source < b.source ? -1 : 1);
+  const videoFacts = [];
+  const unprobed = [];
+  const siblingImages = /* @__PURE__ */ new Set([
+    ...images.map((i) => i.source),
+    ...skipped.map((i) => i.source),
+    ...plan.items.map((i) => i.source)
+  ]);
+  const missingCodecs = /* @__PURE__ */ new Set();
+  const caps = options.videoEngine ? await options.videoEngine.capabilities() : null;
+  if (caps) {
+    if (!caps.libsvtav1 && !caps.libaomAv1) missingCodecs.add("av1");
+    if (!caps.libx264) missingCodecs.add("h264");
+  }
+  let probed = 0;
+  for (const item of plan.videos ?? []) {
+    options.onProgress?.({ phase: "estimate", done: probed++, total });
+    if (item.skip) {
+      if (item.skip.reason.startsWith("needs ffmpeg")) {
+        unprobed.push({ source: item.source, bytes: item.sourceBytes });
+      } else {
+        skipped.push({
+          source: item.source,
+          bytes: item.sourceBytes,
+          reason: item.skip.reason,
+          animatedGif: false
+        });
+      }
+      continue;
+    }
+    const probe = cache.getVideoProbe(item.sourceSha256);
+    if (!probe) continue;
+    const absolute = absoluteOf(item.source);
+    const cacheState = await checkVideoCache(
+      item,
+      manifest?.videos[item.source],
+      outputHash,
+      missingCodecs
+    );
+    const isGif = extname2(item.source).toLowerCase() === ".gif";
+    const covered = cacheState.kind === "hit";
+    const estimate = covered || !options.videoEngine ? null : await estimateVideo(
+      item,
+      {
+        engine: options.videoEngine,
+        cache,
+        ffmpegVersion: videoVersions.ffmpeg ?? "unknown"
+      },
+      absolute
+    );
+    const stem = `${dirname(item.source) === "." ? "" : `${dirname(item.source)}/`}${basename2(item.source, extname2(item.source))}`;
+    const hasPoster = ["jpg", "jpeg", "png", "webp", "avif"].some(
+      (ext) => siblingImages.has(`${stem}.${ext}`) || siblingImages.has(`${stem}-poster.${ext}`) || siblingImages.has(`${stem}_poster.${ext}`)
+    );
+    videoFacts.push({
+      source: item.source,
+      bytes: item.sourceBytes,
+      sha256: item.sourceSha256,
+      probe,
+      faststart: isGif ? null : await isFastStart(absolute).catch(() => null),
+      classification: isGif ? { preset: "gif-to-video", confidence: "high", reason: "animated GIF" } : {
+        // What the plan chose (a per-file or `assets` choice included), as its built-in.
+        preset: rootPreset(policy.catalog, item.preset),
+        confidence: item.classification?.confidence ?? classifyVideo(item.source, probe).confidence,
+        reason: item.classification?.reason ?? classifyVideo(item.source, probe).reason
+      },
+      item,
+      cache: cacheState,
+      estimate,
+      hasPoster,
+      isGif
+    });
+  }
+  let references = null;
+  if (options.scanReferences !== false) {
+    const scan = await scanReferences({ cwd: projectRoot, outDir });
+    references = scan.names;
+    if (scan.truncated) {
+      notes.push("Reference scan hit its size limit; project/unreferenced may over-report.");
+    }
+  }
+  const settings = options.settings ?? {};
+  const settingFor = (id) => {
+    const raw = settings[id];
+    return Array.isArray(raw) ? { severity: raw[0], options: raw[1] } : { severity: raw, options: {} };
+  };
+  const videoEncoders = {};
+  if (caps && videoVersions.ffmpeg) {
+    const av1 = caps.libsvtav1 ? "libsvtav1" : caps.libaomAv1 ? "libaom-av1" : null;
+    if (av1) videoEncoders.av1 = `${av1} (ffmpeg ${videoVersions.ffmpeg})`;
+    if (caps.libx264) videoEncoders.h264 = `libx264 (ffmpeg ${videoVersions.ffmpeg})`;
+  }
+  const ctx = {
+    plan,
+    manifest,
+    videoEncoders,
+    unavailableCodecs: missingCodecs,
+    encoders: engine.encoders(),
+    outputHash,
+    sourceExists: async (source) => (await stat2(absoluteOf(source)).catch(() => null))?.isFile() ?? false,
+    images,
+    skipped,
+    svgs,
+    videos: videoFacts,
+    unprobed: unprobed.map((u) => ({ ...u, reason: `needs ffmpeg: ${needsFfmpeg}` })),
+    references,
+    budgets: options.budgets ?? {},
+    ffmpeg: options.ffmpeg,
+    options: (id) => settingFor(id).options
+  };
+  const ignorePatterns = options.ignore ?? [];
+  const isIgnored = (source) => ignorePatterns.some((p) => matchesGlob(p, source));
+  const ignoreSources = (all) => ignorePatterns.length === 0 ? all : all.filter((f) => !f.source || !isIgnored(f.source));
+  const findings = [];
+  for (const rule of ALL_RULES) {
+    const { severity } = settingFor(rule.id);
+    if (severity === "off") continue;
+    for (const finding of await rule.check(ctx)) {
+      findings.push(severity ? { ...finding, severity } : finding);
+    }
+  }
+  if (unprobed.length > 0) {
+    notes.push(
+      `${unprobed.length} video file${unprobed.length === 1 ? "" : "s"} need ffmpeg to be analysed: ${needsFfmpeg}`
+    );
+  }
+  if (caps && !caps.libsvtav1 && !caps.libaomAv1 && videoFacts.length > 0) {
+    notes.push("No AV1 encoder installed: video estimates use H.264 only.");
+  }
+  if (options.persistCache !== false) await cache.save(fs);
+  const potentialImages = images.reduce(
+    (sum, image) => sum + (image.cache.kind === "hit" ? 0 : savingOf(image) ?? 0),
+    0
+  );
+  const potentialVideos = videoFacts.reduce(
+    (sum, v) => sum + (v.cache.kind === "hit" ? 0 : Math.max(0, v.bytes - (v.estimate?.best.bytes ?? v.bytes))),
+    0
+  );
+  const potential = potentialImages + potentialVideos;
+  const files = [
+    ...images.map((image) => ({
+      source: image.source,
+      bytes: image.bytes,
+      width: image.analysis.width,
+      height: image.analysis.height,
+      format: image.analysis.format,
+      preset: image.item.preset,
+      reason: image.classification.reason,
+      covered: image.cache.kind === "hit",
+      estimatedBytes: image.estimate?.best.bytes ?? null,
+      savingsBytes: savingOf(image) ?? null,
+      plannedOutputs: image.item.outputs.length
+    })),
+    ...videoFacts.map((v) => ({
+      source: v.source,
+      bytes: v.bytes,
+      width: v.probe.width,
+      height: v.probe.height,
+      format: v.isGif ? "gif" : v.probe.videoCodec,
+      kind: "video",
+      durationSec: v.probe.durationSec,
+      preset: v.item.preset,
+      reason: v.classification.reason,
+      covered: v.cache.kind === "hit",
+      estimatedBytes: v.estimate?.best.bytes ?? null,
+      savingsBytes: v.estimate ? Math.max(0, v.bytes - v.estimate.best.bytes) : null,
+      plannedOutputs: v.item.outputs.length
+    })),
+    ...unprobed.map((u) => ({
+      source: u.source,
+      bytes: u.bytes,
+      width: 0,
+      height: 0,
+      format: "-",
+      kind: "video",
+      preset: "-",
+      reason: "",
+      covered: false,
+      estimatedBytes: null,
+      savingsBytes: null,
+      plannedOutputs: 0,
+      skipped: `needs ffmpeg: ${needsFfmpeg}`
+    })),
+    ...plan.items.filter((i) => i.skip).map((i) => ({
+      source: i.source,
+      bytes: i.sourceBytes,
+      width: i.sourceWidth,
+      height: i.sourceHeight,
+      format: "-",
+      preset: "-",
+      reason: "",
+      covered: false,
+      estimatedBytes: null,
+      savingsBytes: null,
+      plannedOutputs: 0,
+      skipped: i.skip.reason
+    }))
+  ].sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+  return {
+    findings: sortFindings(ignoreSources(findings)),
+    unprobed,
+    files: files.filter((f) => !isIgnored(f.source)),
+    counts: {
+      images: images.length,
+      svgs: svgs.length,
+      videos: videoFacts.length + unprobed.length,
+      skipped: skipped.length
+    },
+    totals: {
+      sourceBytes: images.reduce((s, i) => s + i.bytes, 0) + videoFacts.reduce((s, v) => s + v.bytes, 0) + unprobed.reduce((s, u) => s + u.bytes, 0) + skipped.reduce((s, i) => s + i.bytes, 0),
+      potentialSavingsBytes: potential,
+      optimizedImages: images.filter((i) => i.cache.kind === "hit").length + videoFacts.filter((v) => v.cache.kind === "hit").length
+    },
+    notes
+  };
+}
+
+export {
+  audit
+};