bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-TWI2OZJZ.js

@@ -0,0 +1,1432 @@
+#!/usr/bin/env node
+
+// src/core/errors.ts
+var BytecutError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "BytecutError";
+    this.code = code;
+  }
+};
+
+// src/core/units.ts
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const units = ["KB", "MB", "GB"];
+  let value = bytes / 1024;
+  let unit = 0;
+  while (value >= 1024 && unit < units.length - 1) {
+    value /= 1024;
+    unit++;
+  }
+  return `${value.toFixed(value < 10 ? 2 : 1)} ${units[unit]}`;
+}
+function percentChange(before, after) {
+  if (before === 0) return "n/a";
+  const change = Math.round((after - before) / before * 100);
+  return `${change > 0 ? "+" : ""}${change}%`;
+}
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var SIZE_UNITS = {
+  b: 1,
+  kb: 1024,
+  kib: 1024,
+  mb: 1024 ** 2,
+  mib: 1024 ** 2,
+  gb: 1024 ** 3,
+  gib: 1024 ** 3
+};
+function parseSize(text) {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*([a-z]*)\s*$/i.exec(text);
+  if (!match) return null;
+  const factor = SIZE_UNITS[(match[2] ?? "").toLowerCase() || "b"];
+  if (factor === void 0) return null;
+  return Math.round(Number(match[1]) * factor);
+}
+
+// src/core/config/schema.ts
+import { z } from "zod";
+
+// src/core/audit/rules/helpers.ts
+function ruleOptions(ctx, id, defaults) {
+  return { ...defaults, ...ctx.options(id) };
+}
+function isCovered(image) {
+  return image.cache.kind === "hit";
+}
+function savingOf(image) {
+  if (!image.estimate) return void 0;
+  return Math.max(0, image.bytes - image.estimate.best.bytes);
+}
+
+// src/core/audit/rules/cmyk-or-16bit.ts
+var ID = "image/cmyk-or-16bit";
+var cmykOr16bit = {
+  id: ID,
+  category: "image",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const image of ctx.images) {
+      const { space, depth } = image.analysis;
+      const cmyk = space === "cmyk";
+      const deep = depth === "ushort" || depth === "uint" || depth === "float" || depth === "double";
+      if (!cmyk && !deep || isCovered(image)) continue;
+      findings.push({
+        ruleId: ID,
+        severity: "warn",
+        source: image.source,
+        message: cmyk ? "CMYK colour space renders wrongly in browsers; outputs are converted to sRGB" : "16-bit depth is wasted on the web; outputs are 8-bit",
+        current: image.bytes,
+        ...image.estimate ? { estimated: image.estimate.best.bytes } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/duplicate.ts
+var ID2 = "project/duplicate";
+var duplicate = {
+  id: ID2,
+  category: "project",
+  defaultSeverity: "warn",
+  fix: null,
+  async check(ctx) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const file of [...ctx.images, ...ctx.svgs]) {
+      const list = groups.get(file.sha256) ?? [];
+      list.push({ source: file.source, bytes: file.bytes });
+      groups.set(file.sha256, list);
+    }
+    const findings = [];
+    for (const list of groups.values()) {
+      if (list.length < 2) continue;
+      list.sort((a, b) => a.source < b.source ? -1 : 1);
+      const [first, ...copies] = list;
+      findings.push({
+        ruleId: ID2,
+        severity: "warn",
+        source: first.source,
+        message: `identical content in ${copies.length} other file${copies.length === 1 ? "" : "s"}: ${copies.map((c) => c.source).join(", ")}`,
+        current: first.bytes * list.length,
+        savingsBytes: first.bytes * copies.length
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/embedded-raster.ts
+var ID3 = "svg/embedded-raster";
+var svgEmbeddedRaster = {
+  id: ID3,
+  category: "svg",
+  defaultSeverity: "warn",
+  fix: null,
+  async check(ctx) {
+    const { minBytes } = ruleOptions(ctx, ID3, { minBytes: 1024 });
+    const findings = [];
+    for (const svg of ctx.svgs) {
+      if (svg.embeddedRasterCount === 0 || svg.embeddedRasterBytes < minBytes) continue;
+      findings.push({
+        ruleId: ID3,
+        severity: "warn",
+        source: svg.source,
+        message: `embeds ${svg.embeddedRasterCount} raster image${svg.embeddedRasterCount === 1 ? "" : "s"} as base64 (${svg.embeddedRasterBytes} bytes); extract and optimize ${svg.embeddedRasterCount === 1 ? "it" : "them"} separately`,
+        current: svg.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/gif-animated.ts
+import { extname } from "path";
+
+// src/core/audit/rules/video-helpers.ts
+function isVideoCovered(video) {
+  return video.cache.kind === "hit";
+}
+function videoSaving(video) {
+  if (!video.estimate) return void 0;
+  return Math.max(0, video.bytes - video.estimate.best.bytes);
+}
+var UNIVERSAL_CODECS = /* @__PURE__ */ new Set(["h264", "avc1"]);
+var MODERN_CODECS = /* @__PURE__ */ new Set(["av1", "vp9"]);
+function codecLabel(codec) {
+  switch (codec) {
+    case "h264":
+      return "H.264";
+    case "hevc":
+      return "HEVC";
+    case "vp9":
+      return "VP9";
+    case "av1":
+      return "AV1";
+    default:
+      return codec.toUpperCase();
+  }
+}
+
+// src/core/audit/rules/gif-animated.ts
+var ID4 = "gif/animated";
+var gifAnimated = {
+  id: ID4,
+  category: "gif",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (!video.isGif || isVideoCovered(video)) continue;
+      const saving = videoSaving(video);
+      findings.push({
+        ruleId: ID4,
+        severity: "warn",
+        source: video.source,
+        message: "animated GIF; a looping muted video is typically far smaller",
+        current: video.bytes,
+        ...video.estimate ? { estimated: video.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    for (const gif of ctx.unprobed) {
+      if (extname(gif.source).toLowerCase() !== ".gif") continue;
+      findings.push({
+        ruleId: ID4,
+        severity: "warn",
+        source: gif.source,
+        message: `animated GIF; a looping muted video is typically far smaller. Needs ffmpeg: ${ctx.ffmpeg.installHint}`,
+        current: gif.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/gif-static.ts
+var ID5 = "gif/static";
+var gifStatic = {
+  id: ID5,
+  category: "gif",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const image of ctx.images) {
+      if (image.analysis.format !== "gif" || isCovered(image)) continue;
+      const saving = savingOf(image);
+      findings.push({
+        ruleId: ID5,
+        severity: "warn",
+        source: image.source,
+        message: "GIF with a single frame; use a modern still image format",
+        current: image.bytes,
+        ...image.estimate ? { estimated: image.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/heavy.ts
+var ID6 = "image/heavy";
+var heavy = {
+  id: ID6,
+  category: "image",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { maxBytes } = ruleOptions(ctx, ID6, { maxBytes: 500 * 1e3 });
+    const findings = [];
+    for (const image of ctx.images) {
+      if (image.bytes <= maxBytes || isCovered(image)) continue;
+      const saving = savingOf(image);
+      findings.push({
+        ruleId: ID6,
+        severity: "warn",
+        source: image.source,
+        message: `source exceeds the ${maxBytes}-byte limit`,
+        current: image.bytes,
+        ...image.estimate ? { estimated: image.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/metadata.ts
+var ID7 = "image/metadata";
+var metadata = {
+  id: ID7,
+  category: "image",
+  defaultSeverity: "info",
+  fix: "optimize",
+  async check(ctx) {
+    const { minBytes } = ruleOptions(ctx, ID7, { minBytes: 1024 });
+    const findings = [];
+    for (const image of ctx.images) {
+      const m = image.analysis.metadata;
+      const bytes = m.exif + m.xmp + m.iptc;
+      if (bytes < minBytes && !m.gps || isCovered(image)) continue;
+      findings.push({
+        ruleId: ID7,
+        severity: "info",
+        source: image.source,
+        message: m.gps ? "carries embedded metadata including GPS location; outputs strip it" : "carries embedded metadata (EXIF/XMP/IPTC); outputs strip it",
+        current: image.bytes,
+        savingsBytes: bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/no-modern-format.ts
+var ID8 = "image/no-modern-format";
+var noModernFormat = {
+  id: ID8,
+  category: "image",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { minSavingsBytes } = ruleOptions(ctx, ID8, { minSavingsBytes: 1024 });
+    const findings = [];
+    for (const image of ctx.images) {
+      const { format } = image.analysis;
+      if (format !== "jpeg" && format !== "png" && format !== "gif") continue;
+      if (isCovered(image)) continue;
+      const saving = savingOf(image);
+      if (saving === void 0 || saving < minSavingsBytes) continue;
+      findings.push({
+        ruleId: ID8,
+        severity: "warn",
+        source: image.source,
+        message: `${format.toUpperCase()} source has no up-to-date AVIF/WebP outputs`,
+        current: image.bytes,
+        estimated: image.estimate.best.bytes,
+        savingsBytes: saving
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/no-responsive-set.ts
+var ID9 = "image/no-responsive-set";
+var noResponsiveSet = {
+  id: ID9,
+  category: "image",
+  defaultSeverity: "info",
+  fix: "optimize",
+  async check(ctx) {
+    const { minWidth } = ruleOptions(ctx, ID9, { minWidth: 1e3 });
+    const findings = [];
+    for (const image of ctx.images) {
+      if (image.analysis.width < minWidth || isCovered(image)) continue;
+      const widths = new Set(image.item.outputs.map((o) => o.width));
+      if (widths.size < 2) continue;
+      findings.push({
+        ruleId: ID9,
+        severity: "info",
+        source: image.source,
+        message: `${image.analysis.width}px wide with no responsive set (${widths.size} widths would be generated)`,
+        current: image.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/orphaned-output.ts
+var ID10 = "project/orphaned-output";
+var orphanedOutput = {
+  id: ID10,
+  category: "project",
+  defaultSeverity: "info",
+  fix: null,
+  async check(ctx) {
+    const findings = [];
+    if (!ctx.manifest) return findings;
+    const planned = new Map(ctx.plan.items.map((i) => [i.source, i]));
+    for (const [source, entry] of Object.entries(ctx.manifest.sources)) {
+      if (!await ctx.sourceExists(source)) {
+        for (const out of entry.outputs) {
+          findings.push({
+            ruleId: ID10,
+            severity: "info",
+            source,
+            path: out.path,
+            message: "source no longer exists"
+          });
+        }
+        continue;
+      }
+      const item = planned.get(source);
+      if (!item || item.skip) continue;
+      const wanted = new Set(item.outputs.map((o) => o.path));
+      for (const out of entry.outputs) {
+        if (!wanted.has(out.path) && !wanted.has(out.search?.plannedPath ?? "")) {
+          findings.push({
+            ruleId: ID10,
+            severity: "info",
+            source,
+            path: out.path,
+            message: "no longer produced by the current preset"
+          });
+        }
+      }
+    }
+    for (const [source, entry] of Object.entries(ctx.manifest.videos)) {
+      if (!await ctx.sourceExists(source)) {
+        for (const out of entry.outputs) {
+          findings.push({
+            ruleId: ID10,
+            severity: "info",
+            source,
+            path: out.path,
+            message: "source no longer exists"
+          });
+        }
+        continue;
+      }
+      const item = (ctx.plan.videos ?? []).find((v) => v.source === source);
+      if (!item || item.skip) continue;
+      const wanted = new Set(item.outputs.map((o) => o.path));
+      for (const out of entry.outputs) {
+        if (!wanted.has(out.path)) {
+          findings.push({
+            ruleId: ID10,
+            severity: "info",
+            source,
+            path: out.path,
+            message: "no longer produced by the current preset"
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/over-budget.ts
+var ID11 = "project/over-budget";
+function servedBytes(image, ctx) {
+  const entry = ctx.manifest?.sources[image.source];
+  if (image.cache.kind === "hit" && entry) {
+    const written = entry.outputs.filter((o) => o.status === "written");
+    if (written.length > 0) {
+      const widest = Math.max(...written.map((o) => o.width));
+      return Math.min(...written.filter((o) => o.width === widest).map((o) => o.bytes));
+    }
+  }
+  return image.bytes;
+}
+var overBudget = {
+  id: ID11,
+  category: "project",
+  defaultSeverity: "error",
+  fix: null,
+  async check(ctx) {
+    const { maxFileBytes, maxTotalBytes } = ctx.budgets;
+    const findings = [];
+    let total = 0;
+    for (const image of ctx.images) {
+      const bytes = servedBytes(image, ctx);
+      total += bytes;
+      if (maxFileBytes !== void 0 && bytes > maxFileBytes) {
+        findings.push({
+          ruleId: ID11,
+          severity: "error",
+          source: image.source,
+          message: `served size is over the per-file budget of ${maxFileBytes} bytes`,
+          current: bytes
+        });
+      }
+    }
+    if (maxTotalBytes !== void 0 && total > maxTotalBytes) {
+      findings.push({
+        ruleId: ID11,
+        severity: "error",
+        message: `total served image size is over the budget of ${maxTotalBytes} bytes`,
+        current: total
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/oversized-dimensions.ts
+var ID12 = "image/oversized-dimensions";
+var oversizedDimensions = {
+  id: ID12,
+  category: "image",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { maxDimension } = ruleOptions(ctx, ID12, { maxDimension: 2560 });
+    const findings = [];
+    for (const image of ctx.images) {
+      const { width, height } = image.analysis;
+      if (Math.max(width, height) <= maxDimension || isCovered(image)) continue;
+      const cap = image.estimate?.best.width;
+      const saving = savingOf(image);
+      findings.push({
+        ruleId: ID12,
+        severity: "warn",
+        source: image.source,
+        message: `${width}x${height} exceeds ${maxDimension}px${cap ? `; outputs are capped at ${cap}w` : ""}`,
+        current: image.bytes,
+        ...image.estimate ? { estimated: image.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/photo-as-png.ts
+var ID13 = "image/photo-as-png";
+var photoAsPng = {
+  id: ID13,
+  category: "image",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { minColors } = ruleOptions(ctx, ID13, { minColors: 128 });
+    const findings = [];
+    for (const image of ctx.images) {
+      const a = image.analysis;
+      if (a.format !== "png" || a.alphaUsed || isCovered(image)) continue;
+      if (image.classification.preset === "icon" || a.colorCount < minColors) continue;
+      const saving = savingOf(image);
+      findings.push({
+        ruleId: ID13,
+        severity: "warn",
+        source: image.source,
+        message: `photographic content stored as PNG (${a.colorCount} colours in sample, no transparency)`,
+        current: image.bytes,
+        ...image.estimate ? { estimated: image.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/reencode-savings.ts
+var ID14 = "image/reencode-savings";
+var reencodeSavings = {
+  id: ID14,
+  category: "image",
+  defaultSeverity: "info",
+  fix: "optimize",
+  async check(ctx) {
+    const { minPercent, minBytes } = ruleOptions(ctx, ID14, { minPercent: 25, minBytes: 10 * 1024 });
+    const findings = [];
+    for (const image of ctx.images) {
+      const { format } = image.analysis;
+      if (format !== "webp" && format !== "avif" || isCovered(image)) continue;
+      const saving = savingOf(image);
+      if (saving === void 0 || saving < minBytes) continue;
+      if (saving / image.bytes * 100 < minPercent) continue;
+      findings.push({
+        ruleId: ID14,
+        severity: "info",
+        source: image.source,
+        message: `already ${format.toUpperCase()}, but re-encoding at the ${image.item.preset} preset saves a lot`,
+        current: image.bytes,
+        estimated: image.estimate.best.bytes,
+        savingsBytes: saving
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/manifest/cache.ts
+function recordedByPlannedPath(entry) {
+  return new Map(entry.outputs.map((o) => [o.search?.plannedPath ?? o.path, o]));
+}
+function sameSearch(planned, r) {
+  const p = planned.search;
+  const q = r.search;
+  if (!p || !q) return !p && !q;
+  return p.metric === q.metric && p.target === q.target && p.floor === q.floor && p.maxBytes === q.maxBytes;
+}
+async function checkCache(item, entry, hashOutput) {
+  if (!entry) return { kind: "miss", reason: "new" };
+  if (entry.sha256 !== item.sourceSha256) return { kind: "miss", reason: "source-changed" };
+  if (entry.preset !== item.preset) return { kind: "miss", reason: "outputs-differ" };
+  const recorded = recordedByPlannedPath(entry);
+  for (const planned of item.outputs) {
+    const r = recorded.get(planned.path);
+    const searched = planned.search !== void 0;
+    if (!r || r.format !== planned.format || r.lossless !== planned.lossless || r.effort !== planned.effort || !sameSearch(planned, r) || (searched ? r.width > planned.width : r.width !== planned.width || r.quality !== planned.quality)) {
+      return { kind: "miss", reason: "outputs-differ" };
+    }
+  }
+  for (const planned of item.outputs) {
+    const r = recorded.get(planned.path);
+    if (r.status === "stale") return { kind: "miss", reason: "output-stale" };
+    if (r.status !== "written") continue;
+    const actual = await hashOutput(r.path);
+    if (actual === null) return { kind: "miss", reason: "output-missing" };
+    if (actual !== r.sha256) return { kind: "miss", reason: "output-modified" };
+  }
+  return { kind: "hit" };
+}
+function sameVideoParams(planned, r) {
+  if (planned.role !== r.role || planned.path !== r.path || planned.width !== r.width) return false;
+  if (planned.role === "video") {
+    const search = planned.search;
+    const sameSearch2 = search === void 0 ? r.search === void 0 && r.crf === planned.crf : r.search?.metric === search.metric && r.search.target === search.target;
+    return sameSearch2 && r.codec === planned.codec && r.speed === planned.speed && r.maxWidth === planned.maxWidth && r.maxFps === planned.maxFps && r.audio === planned.audio;
+  }
+  return r.quality === planned.quality && r.effort === planned.effort && r.at === planned.at;
+}
+async function checkVideoCache(item, entry, hashOutput, unavailable = /* @__PURE__ */ new Set()) {
+  if (!entry) return { kind: "miss", reason: "new" };
+  if (entry.sha256 !== item.sourceSha256) return { kind: "miss", reason: "source-changed" };
+  if (entry.preset !== item.preset) return { kind: "miss", reason: "outputs-differ" };
+  const recorded = new Map(entry.outputs.map((o) => [o.path, o]));
+  const wanted = item.outputs.filter((o) => !(o.role === "video" && unavailable.has(o.codec)));
+  for (const planned of wanted) {
+    const r = recorded.get(planned.path);
+    if (!r || !sameVideoParams(planned, r)) return { kind: "miss", reason: "outputs-differ" };
+  }
+  for (const planned of wanted) {
+    const r = recorded.get(planned.path);
+    if (r.status === "stale") return { kind: "miss", reason: "output-stale" };
+    if (r.status !== "written") continue;
+    const actual = await hashOutput(planned.path);
+    if (actual === null) return { kind: "miss", reason: "output-missing" };
+    if (actual !== r.sha256) return { kind: "miss", reason: "output-modified" };
+  }
+  return { kind: "hit" };
+}
+
+// src/core/audit/rules/stale-output.ts
+var ID15 = "project/stale-output";
+var REASONS = {
+  "source-changed": "source changed since the last run; will be regenerated",
+  "outputs-differ": "preset or widths differ from what was last generated; will be regenerated",
+  "output-missing": "an output file is missing; will be regenerated",
+  "output-modified": "an output file was modified after it was written; it is left alone unless you use --force",
+  "output-stale": "an output was left over from an older source (a run did not complete); will be regenerated"
+};
+var staleOutput = {
+  id: ID15,
+  category: "project",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    if (!ctx.manifest) return findings;
+    for (const item of ctx.plan.items) {
+      if (item.skip) continue;
+      const entry = ctx.manifest.sources[item.source];
+      const state = await checkCache(item, entry, ctx.outputHash);
+      if (state.kind === "miss" && state.reason !== "new") {
+        findings.push({
+          ruleId: ID15,
+          severity: "warn",
+          source: item.source,
+          message: REASONS[state.reason]
+        });
+        continue;
+      }
+      for (const out of entry?.outputs ?? []) {
+        const current = ctx.encoders[out.format];
+        if (out.status === "written" && out.encoder !== current) {
+          findings.push({
+            ruleId: ID15,
+            severity: "warn",
+            source: item.source,
+            path: out.path,
+            message: `encoded with ${out.encoder}, installed is ${current}; run with --force to regenerate`
+          });
+        }
+      }
+    }
+    for (const item of ctx.plan.videos ?? []) {
+      if (item.skip) continue;
+      const entry = ctx.manifest.videos[item.source];
+      const state = await checkVideoCache(item, entry, ctx.outputHash, ctx.unavailableCodecs);
+      if (state.kind === "miss" && state.reason !== "new") {
+        findings.push({
+          ruleId: ID15,
+          severity: "warn",
+          source: item.source,
+          message: REASONS[state.reason]
+        });
+        continue;
+      }
+      for (const out of entry?.outputs ?? []) {
+        if (out.status !== "written" || out.role !== "video" || !out.codec) continue;
+        const current = ctx.videoEncoders?.[out.codec];
+        if (current && out.encoder !== current) {
+          findings.push({
+            ruleId: ID15,
+            severity: "warn",
+            source: item.source,
+            path: out.path,
+            message: `encoded with ${out.encoder}, installed is ${current}; run with --force to regenerate`
+          });
+        }
+      }
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-audio-in-background.ts
+var ID16 = "video/audio-in-background";
+var videoAudioInBackground = {
+  id: ID16,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (!video.probe.hasAudio || video.classification.preset !== "background-video") continue;
+      if (isVideoCovered(video)) continue;
+      findings.push({
+        ruleId: ID16,
+        severity: "warn",
+        source: video.source,
+        message: "looks like a background video but carries an audio track; outputs drop it",
+        current: video.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-high-bitrate.ts
+var ID17 = "video/high-bitrate";
+var videoHighBitrate = {
+  id: ID17,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { maxBitsPerPixel, minBytes } = ruleOptions(ctx, ID17, {
+      maxBitsPerPixel: 0.2,
+      minBytes: 200 * 1024
+    });
+    const findings = [];
+    for (const video of ctx.videos) {
+      const { bitrate, width, height, fps } = video.probe;
+      if (bitrate === null || width * height * fps === 0) continue;
+      if (video.bytes < minBytes || isVideoCovered(video)) continue;
+      const bpp = bitrate / (width * height * fps);
+      if (bpp <= maxBitsPerPixel) continue;
+      const saving = videoSaving(video);
+      findings.push({
+        ruleId: ID17,
+        severity: "warn",
+        source: video.source,
+        message: `${bpp.toFixed(2)} bits per pixel per frame (over ${maxBitsPerPixel})`,
+        current: video.bytes,
+        ...video.estimate ? { estimated: video.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-high-fps.ts
+var ID18 = "video/high-fps";
+var videoHighFps = {
+  id: ID18,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { maxFps } = ruleOptions(ctx, ID18, { maxFps: 30 });
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (video.probe.fps <= maxFps + 0.01 || isVideoCovered(video)) continue;
+      const capped = video.classification.preset === "background-video";
+      findings.push({
+        ruleId: ID18,
+        severity: capped ? "warn" : "info",
+        source: video.source,
+        message: capped ? `${Math.round(video.probe.fps)} fps is more than a backdrop needs; outputs are capped at ${maxFps}` : `${Math.round(video.probe.fps)} fps; kept as-is because it looks like content`,
+        current: video.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-no-fallback.ts
+var ID19 = "video/no-fallback";
+var videoNoFallback = {
+  id: ID19,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (video.isGif || UNIVERSAL_CODECS.has(video.probe.videoCodec)) continue;
+      if (isVideoCovered(video)) continue;
+      findings.push({
+        ruleId: ID19,
+        severity: "warn",
+        source: video.source,
+        message: `${codecLabel(video.probe.videoCodec)} is not playable everywhere and there is no H.264 MP4 fallback`,
+        current: video.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-no-faststart.ts
+var ID20 = "video/no-faststart";
+var videoNoFaststart = {
+  id: ID20,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (video.faststart !== false || isVideoCovered(video)) continue;
+      findings.push({
+        ruleId: ID20,
+        severity: "warn",
+        source: video.source,
+        message: "moov atom is after the media data, so playback waits for the whole file; outputs are faststart",
+        current: video.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-no-modern-codec.ts
+var ID21 = "video/no-modern-codec";
+var videoNoModernCodec = {
+  id: ID21,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { minSavingsBytes } = ruleOptions(ctx, ID21, { minSavingsBytes: 10 * 1024 });
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (video.isGif) continue;
+      if (MODERN_CODECS.has(video.probe.videoCodec) || isVideoCovered(video)) continue;
+      const saving = videoSaving(video);
+      if (saving !== void 0 && saving < minSavingsBytes) continue;
+      findings.push({
+        ruleId: ID21,
+        severity: "warn",
+        source: video.source,
+        message: `${codecLabel(video.probe.videoCodec)} source has no AV1 output`,
+        current: video.bytes,
+        ...video.estimate ? { estimated: video.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-no-poster.ts
+var ID22 = "video/no-poster";
+var videoNoPoster = {
+  id: ID22,
+  category: "video",
+  defaultSeverity: "info",
+  fix: "optimize",
+  async check(ctx) {
+    const findings = [];
+    for (const video of ctx.videos) {
+      if (video.hasPoster || isVideoCovered(video)) continue;
+      findings.push({
+        ruleId: ID22,
+        severity: "info",
+        source: video.source,
+        message: "no poster image, so nothing shows before the first frame loads; one is generated",
+        current: video.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/video-oversized-resolution.ts
+var ID23 = "video/oversized-resolution";
+var videoOversizedResolution = {
+  id: ID23,
+  category: "video",
+  defaultSeverity: "warn",
+  fix: "optimize",
+  async check(ctx) {
+    const { maxWidth } = ruleOptions(ctx, ID23, { maxWidth: 1920 });
+    const findings = [];
+    for (const video of ctx.videos) {
+      const { width, height } = video.probe;
+      if (Math.max(width, height) <= maxWidth || isVideoCovered(video)) continue;
+      const capped = video.classification.preset !== "content-video";
+      const saving = videoSaving(video);
+      findings.push({
+        ruleId: ID23,
+        severity: capped ? "warn" : "info",
+        source: video.source,
+        message: capped ? `${width}x${height} exceeds ${maxWidth}px; outputs are capped` : `${width}x${height} exceeds ${maxWidth}px; kept as-is because it looks like content (use the background-video preset to cap it)`,
+        current: video.bytes,
+        ...video.estimate ? { estimated: video.estimate.best.bytes } : {},
+        ...saving !== void 0 ? { savingsBytes: saving } : {}
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/unminified.ts
+var ID24 = "svg/unminified";
+var svgUnminified = {
+  id: ID24,
+  category: "svg",
+  defaultSeverity: "warn",
+  fix: null,
+  async check(ctx) {
+    const { minPercent, minBytes } = ruleOptions(ctx, ID24, { minPercent: 10, minBytes: 256 });
+    const findings = [];
+    for (const svg of ctx.svgs) {
+      if (svg.minifiedBytes === null) continue;
+      const saving = svg.bytes - svg.minifiedBytes;
+      if (saving < minBytes || saving / svg.bytes * 100 < minPercent) continue;
+      findings.push({
+        ruleId: ID24,
+        severity: "warn",
+        source: svg.source,
+        message: "contains comments, metadata or whitespace that svgo removes",
+        current: svg.bytes,
+        estimated: svg.minifiedBytes,
+        savingsBytes: saving
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/unreferenced.ts
+var ID25 = "project/unreferenced";
+var unreferenced = {
+  id: ID25,
+  category: "project",
+  defaultSeverity: "info",
+  fix: null,
+  async check(ctx) {
+    if (!ctx.references) return [];
+    const refs = ctx.references;
+    const findings = [];
+    const files = [
+      ...ctx.images.map((i) => ({ source: i.source, bytes: i.bytes })),
+      ...ctx.skipped.map((s) => ({ source: s.source, bytes: s.bytes })),
+      ...ctx.svgs.map((s) => ({ source: s.source, bytes: s.bytes }))
+    ];
+    for (const file of files) {
+      const name = file.source.split("/").pop().toLowerCase();
+      if (refs.has(name)) continue;
+      findings.push({
+        ruleId: ID25,
+        severity: "info",
+        source: file.source,
+        message: "no reference to this file name found in project source files",
+        current: file.bytes,
+        savingsBytes: file.bytes
+      });
+    }
+    return findings;
+  }
+};
+
+// src/core/audit/rules/index.ts
+var PROJECT_RULES = [staleOutput, orphanedOutput];
+var ALL_RULES = [
+  noModernFormat,
+  oversizedDimensions,
+  heavy,
+  photoAsPng,
+  reencodeSavings,
+  metadata,
+  noResponsiveSet,
+  cmykOr16bit,
+  svgUnminified,
+  svgEmbeddedRaster,
+  gifAnimated,
+  gifStatic,
+  videoNoModernCodec,
+  videoNoFallback,
+  videoOversizedResolution,
+  videoHighFps,
+  videoHighBitrate,
+  videoAudioInBackground,
+  videoNoFaststart,
+  videoNoPoster,
+  duplicate,
+  unreferenced,
+  overBudget,
+  staleOutput,
+  orphanedOutput
+];
+
+// src/core/config/schema.ts
+var M9 = "arrives with perceptual quality search in M9; use `target` for now";
+var size = z.union([z.number().int().nonnegative(), z.string()]).transform((value, ctx) => {
+  if (typeof value === "number") return value;
+  const bytes = parseSize(value);
+  if (bytes === null) {
+    ctx.addIssue({ code: "custom", message: `"${value}" is not a size (try "250 KB" or 262144)` });
+    return z.NEVER;
+  }
+  return bytes;
+});
+var severity = z.enum(["error", "warn", "info", "off"]);
+var ruleSetting = z.union([severity, z.tuple([severity, z.record(z.string(), z.unknown())])]);
+var quality = z.number().int().min(1).max(100);
+var TARGETS = ["low", "balanced", "high", "lossless"];
+var PLACEHOLDERS = ["dominant-color", "lqip", "blurhash", "none"];
+var FRAMEWORKS = ["next", "astro", "vite", "static"];
+var rejected = (what, why = M9) => z.unknown().optional().superRefine((value, ctx) => {
+  if (value !== void 0) ctx.addIssue({ code: "custom", message: `${what} ${why}` });
+});
+var qualityByFormat = z.object({ avif: quality.optional(), webp: quality.optional() }).strict();
+var effortByFormat = z.object({
+  avif: z.number().int().min(0).max(9).optional(),
+  webp: z.number().int().min(0).max(6).optional()
+}).strict();
+var crfByCodec = z.object({
+  av1: z.number().int().min(0).max(63).optional(),
+  h264: z.number().int().min(0).max(51).optional()
+}).strict();
+var presetSchema = z.object({
+  extends: z.string().min(1).optional(),
+  target: z.enum(TARGETS).optional(),
+  // images
+  widths: z.array(z.number().int().min(16).max(16384)).min(1).optional(),
+  formats: z.array(z.enum(["avif", "webp"])).min(1).optional(),
+  quality: qualityByFormat.optional(),
+  effort: effortByFormat.optional(),
+  lossless: z.boolean().optional(),
+  priority: z.boolean().optional(),
+  // video
+  audio: z.enum(["keep", "strip"]).optional(),
+  maxWidth: z.number().int().min(16).nullable().optional(),
+  maxFps: z.number().int().min(1).nullable().optional(),
+  codecs: z.array(z.enum(["av1", "h264"])).min(1).optional(),
+  crf: crfByCodec.optional(),
+  // perceptual search: images and video (`floor` and `maxSize` are image-only)
+  ssimulacra2: z.number().min(1).max(100).optional(),
+  vmaf: z.number().min(1).max(100).optional(),
+  floor: z.number().min(1).max(100).optional(),
+  maxSize: size.optional(),
+  // reserved
+  raw: rejected("`raw`", "is not supported; use `target`, `quality` or `crf`")
+}).strict().superRefine((preset, ctx) => {
+  const say = (path, message) => ctx.addIssue({ code: "custom", path: [path], message });
+  if (preset.vmaf !== void 0 && preset.ssimulacra2 !== void 0) {
+    say("vmaf", "cannot be combined with `ssimulacra2`: a preset searches for one metric");
+  }
+  if (preset.floor !== void 0 && preset.ssimulacra2 === void 0) {
+    say(
+      "floor",
+      "needs `ssimulacra2`: it is the lowest score allowed when `maxSize` forces quality down"
+    );
+  }
+  if (preset.maxSize !== void 0 && preset.ssimulacra2 === void 0) {
+    say(
+      "maxSize",
+      "needs `ssimulacra2`, so there is a quality target to hold while fitting the size"
+    );
+  }
+  if (preset.maxSize !== void 0 && preset.floor === void 0) {
+    say(
+      "floor",
+      "is required with `maxSize`: how far quality may drop to fit is a tradeoff to state, not a default"
+    );
+  }
+  if (preset.floor !== void 0 && preset.ssimulacra2 !== void 0 && preset.floor > preset.ssimulacra2) {
+    say("floor", `must not exceed \`ssimulacra2\` (${preset.ssimulacra2})`);
+  }
+  if (preset.floor !== void 0 && preset.maxSize === void 0 && preset.ssimulacra2 !== void 0) {
+    say("floor", "only applies with `maxSize`");
+  }
+});
+var knownRuleIds = new Set(ALL_RULES.map((rule) => rule.id));
+var auditSchema = z.object({
+  rules: z.record(z.string(), ruleSetting).superRefine((rules, ctx) => {
+    for (const id of Object.keys(rules)) {
+      if (!knownRuleIds.has(id)) {
+        ctx.addIssue({
+          code: "custom",
+          path: [id],
+          message: `unknown rule${hint(id, [...knownRuleIds])}`
+        });
+      }
+    }
+  }).optional(),
+  ignore: z.array(z.string().min(1)).optional()
+}).strict();
+var budgetsSchema = z.object({ maxFileSize: size.optional(), maxTotalSize: size.optional() }).strict();
+var manifestSchema = z.object({ placeholder: z.enum(PLACEHOLDERS).optional() }).strict();
+var configSchema = z.object({
+  $schema: z.string().optional(),
+  include: z.array(z.string().min(1)).optional(),
+  exclude: z.array(z.string().min(1)).optional(),
+  outDir: z.string().min(1).optional(),
+  publicPath: z.string().regex(/^(\/|https?:\/\/)/, 'must start with "/" or be an http(s) URL').optional(),
+  framework: z.enum(FRAMEWORKS).optional(),
+  assets: z.record(z.string().min(1), z.string().min(1)).optional(),
+  presets: z.record(z.string().min(1), presetSchema).optional(),
+  audit: auditSchema.optional(),
+  budgets: budgetsSchema.optional(),
+  manifest: manifestSchema.optional(),
+  concurrency: z.number().int().min(1).max(16).optional(),
+  ffmpegPath: z.string().min(1).optional(),
+  ffprobePath: z.string().min(1).optional(),
+  ssimulacra2Path: z.string().min(1).optional()
+}).strict();
+function distance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, i) => i);
+  for (let i = 1; i <= a.length; i++) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j++) {
+      const current = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = current;
+    }
+  }
+  return row[b.length];
+}
+function hint(wrong, candidates) {
+  let best;
+  let bestDistance = Infinity;
+  for (const candidate of candidates) {
+    const d = distance(wrong.toLowerCase(), candidate.toLowerCase());
+    if (d < bestDistance) [best, bestDistance] = [candidate, d];
+  }
+  return best !== void 0 && bestDistance <= Math.max(2, Math.floor(wrong.length / 3)) ? ` (did you mean "${best}"?)` : "";
+}
+function keysAt(path) {
+  const p = path.map(String);
+  if (p.length === 0) return Object.keys(configSchema.shape);
+  if (p[0] === "presets") {
+    if (p.length === 2) return Object.keys(presetSchema.shape);
+    if (p[2] === "quality") return Object.keys(qualityByFormat.shape);
+    if (p[2] === "effort") return Object.keys(effortByFormat.shape);
+    if (p[2] === "crf") return Object.keys(crfByCodec.shape);
+  }
+  if (p[0] === "audit" && p.length === 1) return Object.keys(auditSchema.shape);
+  if (p[0] === "budgets") return Object.keys(budgetsSchema.shape);
+  if (p[0] === "manifest") return Object.keys(manifestSchema.shape);
+  return [];
+}
+function describePath(path) {
+  return path.length === 0 ? "(config)" : path.map(String).join(".");
+}
+function formatConfigIssues(issues) {
+  const lines = [];
+  for (const issue of issues) {
+    if (issue.code === "unrecognized_keys") {
+      for (const key of issue.keys) {
+        const known = keysAt(issue.path);
+        lines.push(
+          `${describePath(issue.path)}: unknown key "${key}"${hint(key, known)}${known.length ? ` \u2014 valid keys: ${known.join(", ")}` : ""}`
+        );
+      }
+    } else if (issue.code === "invalid_value" && issue.values.length > 0) {
+      lines.push(
+        `${describePath(issue.path)}: must be one of ${issue.values.map((v) => JSON.stringify(v)).join(", ")}`
+      );
+    } else {
+      lines.push(`${describePath(issue.path)}: ${issue.message}`);
+    }
+  }
+  return lines;
+}
+function parseConfig(raw, fileName) {
+  const result = configSchema.safeParse(raw);
+  if (result.success) return result.data;
+  const lines = formatConfigIssues(result.error.issues);
+  throw new BytecutError(
+    "CONFIG_INVALID",
+    `${fileName} is not a valid bytecut config:
+${lines.map((l) => `  - ${l}`).join("\n")}`
+  );
+}
+
+// src/core/config/load.ts
+import { readFile, stat } from "fs/promises";
+import { basename, extname as extname2, relative, resolve } from "path";
+import { pathToFileURL } from "url";
+import { parse as parseToml } from "smol-toml";
+
+// src/core/config/files.ts
+var CONFIG_FILES = [
+  "bytecut.config.ts",
+  "bytecut.config.mts",
+  "bytecut.config.js",
+  "bytecut.config.mjs",
+  "bytecut.config.json",
+  "bytecut.config.toml"
+];
+
+// src/core/config/load.ts
+var formatOf = (file) => {
+  const ext = extname2(file).toLowerCase();
+  if (ext === ".json") return "json";
+  if (ext === ".toml") return "toml";
+  return ext === ".ts" || ext === ".mts" ? "ts" : "js";
+};
+var invalid = (name, message, cause) => new BytecutError("CONFIG_INVALID", `${name}: ${message}`, cause ? { cause } : void 0);
+async function importConfig(file, name) {
+  const original = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    const text = typeof warning === "string" ? warning : warning.message;
+    if (/type stripping/i.test(text)) return;
+    return original.call(process, warning, ...rest);
+  });
+  try {
+    const mod = await import(pathToFileURL(file).href);
+    let value = mod.default;
+    if (typeof value === "function") value = await value();
+    if (value === void 0 || value === null || typeof value !== "object") {
+      throw invalid(name, "must `export default` a config object");
+    }
+    return value;
+  } catch (error) {
+    if (error instanceof BytecutError) throw error;
+    const code = error.code;
+    const message = error instanceof Error ? error.message : String(error);
+    if (code === "ERR_UNKNOWN_FILE_EXTENSION") {
+      throw invalid(
+        name,
+        `this Node (${process.version}) cannot load TypeScript files. Use Node 22.18 or newer, or write the config as bytecut.config.json.`,
+        error
+      );
+    }
+    if (code === "ERR_UNSUPPORTED_TYPESCRIPT_SYNTAX") {
+      throw invalid(
+        name,
+        `uses TypeScript syntax Node cannot strip (${message}). Keep the config a plain object.`,
+        error
+      );
+    }
+    throw invalid(name, `could not be loaded: ${message}`, error);
+  } finally {
+    process.emitWarning = original;
+  }
+}
+async function readRaw(file, name, format) {
+  if (format === "ts" || format === "js") return importConfig(file, name);
+  const text = await readFile(file, "utf8");
+  try {
+    return format === "json" ? JSON.parse(text) : parseToml(text);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw invalid(name, `is not valid ${format === "json" ? "JSON" : "TOML"}: ${message}`, error);
+  }
+}
+async function findConfigFiles(projectRoot) {
+  const found = [];
+  for (const name of CONFIG_FILES) {
+    const info = await stat(resolve(projectRoot, name)).catch(() => null);
+    if (info?.isFile()) found.push(name);
+  }
+  return found;
+}
+async function loadConfig(projectRoot, explicit) {
+  let file;
+  if (explicit) {
+    file = resolve(projectRoot, explicit);
+    const info = await stat(file).catch(() => null);
+    if (!info?.isFile()) {
+      throw new BytecutError("INPUT_NOT_FOUND", `No such config file: ${explicit}`);
+    }
+  } else {
+    const found = await findConfigFiles(projectRoot);
+    if (found.length === 0) return null;
+    if (found.length > 1) {
+      throw new BytecutError(
+        "CONFIG_INVALID",
+        `More than one config file found (${found.join(", ")}). Keep one, or pick with --config.`
+      );
+    }
+    file = resolve(projectRoot, found[0]);
+  }
+  const name = relative(projectRoot, file) || basename(file);
+  const format = formatOf(file);
+  const raw = await readRaw(file, name, format);
+  return { file, name, format, config: parseConfig(raw, name), raw };
+}
+
+// src/core/scan/detect.ts
+import { readFile as readFile2, readdir, stat as stat2 } from "fs/promises";
+import { join } from "path";
+var FRAMEWORK_CONFIG = [
+  ["next", /^next\.config\.(js|mjs|cjs|ts)$/],
+  ["astro", /^astro\.config\.(js|mjs|cjs|ts)$/],
+  ["vite", /^vite\.config\.(js|mjs|cjs|ts|mts|cts)$/]
+];
+var FRAMEWORK_DEP = [
+  ["next", "next"],
+  ["astro", "astro"],
+  ["vite", "vite"]
+];
+async function isDirectory(path) {
+  return (await stat2(path).catch(() => null))?.isDirectory() ?? false;
+}
+async function readDependencies(root) {
+  try {
+    const pkg = JSON.parse(await readFile2(join(root, "package.json"), "utf8"));
+    const names = /* @__PURE__ */ new Set();
+    for (const key of ["dependencies", "devDependencies", "peerDependencies"]) {
+      const section = pkg[key];
+      if (section && typeof section === "object") {
+        for (const name of Object.keys(section)) names.add(name);
+      }
+    }
+    return names;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+async function detectProject(root, options = {}) {
+  const deps = await readDependencies(root);
+  const files = await readdir(root).catch(() => []);
+  let framework = "static";
+  for (const [candidate, dep] of FRAMEWORK_DEP) {
+    const byConfig = FRAMEWORK_CONFIG.some(
+      ([name, re]) => name === candidate && files.some((f) => re.test(f))
+    );
+    if (deps.has(dep) || byConfig) {
+      framework = candidate;
+      break;
+    }
+  }
+  if (options.framework) framework = options.framework;
+  const react = deps.has("react");
+  const hasPublic = await isDirectory(join(root, "public"));
+  if (framework !== "static" || hasPublic) {
+    return {
+      framework,
+      react,
+      include: ["public"],
+      outDir: "public/_bytecut",
+      publicPath: "/_bytecut",
+      staticRoot: "public"
+    };
+  }
+  return {
+    framework,
+    react,
+    include: ["."],
+    outDir: "_bytecut",
+    publicPath: "/_bytecut",
+    staticRoot: "."
+  };
+}
+
+// src/core/config/glob.ts
+var SPECIAL = /[\\^$.|+()]/;
+function bracesPair(pattern) {
+  let depth = 0;
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] === "\\") i++;
+    else if (pattern[i] === "{") depth++;
+    else if (pattern[i] === "}" && --depth < 0) return false;
+  }
+  return depth === 0;
+}
+function translate(pattern) {
+  let out = "";
+  let braceDepth = 0;
+  const alternation = bracesPair(pattern);
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i];
+    if (ch === "\\") {
+      const next = pattern[++i];
+      if (next !== void 0) out += next.replace(/[.*+?^${}()|[\]\\/-]/g, "\\$&");
+    } else if (ch === "*") {
+      if (pattern[i + 1] === "*") {
+        i++;
+        if (pattern[i + 1] === "/") {
+          i++;
+          out += "(?:.*/)?";
+        } else out += ".*";
+      } else out += "[^/]*";
+    } else if (ch === "?") out += "[^/]";
+    else if (ch === "{" && alternation) {
+      braceDepth++;
+      out += "(?:";
+    } else if (ch === "}" && alternation) {
+      braceDepth--;
+      out += ")";
+    } else if (ch === "," && braceDepth > 0) out += "|";
+    else if (ch === "[") {
+      const end = pattern.indexOf("]", i + 2);
+      if (end === -1) out += "\\[";
+      else {
+        let body = pattern.slice(i + 1, end);
+        if (body.startsWith("!")) body = `^${body.slice(1)}`;
+        out += `[${body.replace(/\\/g, "\\\\")}]`;
+        i = end;
+      }
+    } else if (SPECIAL.test(ch) || ch === "{" || ch === "}") out += `\\${ch}`;
+    else out += ch;
+  }
+  return out;
+}
+function hasSlash(pattern) {
+  return pattern.replace(/\\./g, "").includes("/");
+}
+function globToRegExp(pattern) {
+  const body = translate(pattern.replace(/^\.\//, ""));
+  return new RegExp(hasSlash(pattern) ? `^${body}$` : `^(?:.*/)?${body}$`);
+}
+function matchesGlob(pattern, path) {
+  return globToRegExp(pattern).test(path);
+}
+function escapeGlob(path) {
+  return path.replace(/[\\*?[\]{}]/g, "\\$&");
+}
+
+export {
+  BytecutError,
+  savingOf,
+  recordedByPlannedPath,
+  checkCache,
+  checkVideoCache,
+  PROJECT_RULES,
+  ALL_RULES,
+  CONFIG_FILES,
+  matchesGlob,
+  escapeGlob,
+  formatBytes,
+  percentChange,
+  plural,
+  PLACEHOLDERS,
+  FRAMEWORKS,
+  hint,
+  parseConfig,
+  findConfigFiles,
+  loadConfig,
+  detectProject
+};