bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-XFJ3HW4X.js

@@ -0,0 +1,248 @@
+#!/usr/bin/env node
+
+// src/core/engines/image.ts
+import sharp from "sharp";
+
+// src/core/placeholders/blurhash.ts
+var ALPHABET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~";
+function encode83(value, length) {
+  let out = "";
+  for (let i = 1; i <= length; i++) {
+    const digit = Math.floor(value / 83 ** (length - i)) % 83;
+    out += ALPHABET[digit];
+  }
+  return out;
+}
+function sRGBToLinear(value) {
+  const v = value / 255;
+  return v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4;
+}
+function linearToSRGB(value) {
+  const v = Math.max(0, Math.min(1, value));
+  return v <= 31308e-7 ? Math.trunc(v * 12.92 * 255 + 0.5) : Math.trunc((1.055 * v ** (1 / 2.4) - 0.055) * 255 + 0.5);
+}
+var signPow = (value, exp) => Math.sign(value) * Math.abs(value) ** exp;
+function basisFactor(pixels, width, height, xc, yc) {
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  const normalisation = xc === 0 && yc === 0 ? 1 : 2;
+  const bytesPerRow = width * 4;
+  for (let x = 0; x < width; x++) {
+    for (let y = 0; y < height; y++) {
+      const basis = normalisation * Math.cos(Math.PI * xc * x / width) * Math.cos(Math.PI * yc * y / height);
+      r += basis * sRGBToLinear(pixels[4 * x + y * bytesPerRow]);
+      g += basis * sRGBToLinear(pixels[4 * x + 1 + y * bytesPerRow]);
+      b += basis * sRGBToLinear(pixels[4 * x + 2 + y * bytesPerRow]);
+    }
+  }
+  const scale = 1 / (width * height);
+  return [r * scale, g * scale, b * scale];
+}
+function encodeBlurhash(pixels, width, height, componentX, componentY) {
+  if (componentX < 1 || componentX > 9 || componentY < 1 || componentY > 9) {
+    throw new RangeError("BlurHash needs 1 to 9 components per axis");
+  }
+  if (pixels.length !== width * height * 4) {
+    throw new RangeError("Pixel buffer does not match the given width and height");
+  }
+  const factors = [];
+  for (let y = 0; y < componentY; y++) {
+    for (let x = 0; x < componentX; x++) {
+      factors.push(basisFactor(pixels, width, height, x, y));
+    }
+  }
+  const dc = factors[0];
+  const ac = factors.slice(1);
+  let hash = encode83(componentX - 1 + (componentY - 1) * 9, 1);
+  let maximumValue;
+  if (ac.length > 0) {
+    const actualMax = Math.max(...ac.flatMap((f) => f.map(Math.abs)));
+    const quantisedMax = Math.max(0, Math.min(82, Math.floor(actualMax * 166 - 0.5)));
+    maximumValue = (quantisedMax + 1) / 166;
+    hash += encode83(quantisedMax, 1);
+  } else {
+    maximumValue = 1;
+    hash += encode83(0, 1);
+  }
+  hash += encode83(
+    (linearToSRGB(dc[0]) << 16) + (linearToSRGB(dc[1]) << 8) + linearToSRGB(dc[2]),
+    4
+  );
+  for (const f of ac) {
+    const q = (v) => Math.max(0, Math.min(18, Math.floor(signPow(v / maximumValue, 0.5) * 9 + 9.5)));
+    hash += encode83(q(f[0]) * 19 * 19 + q(f[1]) * 19 + q(f[2]), 2);
+  }
+  return hash;
+}
+function componentsFor(width, height) {
+  if (width <= 0 || height <= 0) return [4, 3];
+  const ratio = width / height;
+  if (ratio > 1.25) return [4, 3];
+  if (ratio < 0.8) return [3, 4];
+  return [4, 4];
+}
+
+// src/core/engines/exif.ts
+function hasGpsIfd(exif) {
+  const base = exif.subarray(0, 6).toString("latin1") === "Exif\0\0" ? 6 : 0;
+  if (exif.length < base + 8) return false;
+  const order = exif.toString("latin1", base, base + 2);
+  const little = order === "II";
+  if (!little && order !== "MM") return false;
+  const u16 = (at) => little ? exif.readUInt16LE(at) : exif.readUInt16BE(at);
+  const u32 = (at) => little ? exif.readUInt32LE(at) : exif.readUInt32BE(at);
+  const ifd0 = base + u32(base + 4);
+  if (ifd0 + 2 > exif.length) return false;
+  const count = u16(ifd0);
+  for (let i = 0; i < count; i++) {
+    const entry = ifd0 + 2 + i * 12;
+    if (entry + 12 > exif.length) return false;
+    if (u16(entry) === 34853) return true;
+  }
+  return false;
+}
+
+// src/core/engines/image.ts
+function sourceFormat(format, compression) {
+  switch (format) {
+    case "jpeg":
+    case "png":
+    case "webp":
+    case "gif":
+      return format;
+    case "heif":
+      return compression === "av1" ? "avif" : "other";
+    default:
+      return "other";
+  }
+}
+var SAMPLE_EDGE = 64;
+async function sampleColors(input) {
+  const { data, info } = await sharp(input).rotate().resize(SAMPLE_EDGE, SAMPLE_EDGE, { fit: "inside", kernel: "nearest" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i + 3 < data.length; i += 4) {
+    const a = data[i + 3];
+    const key = a === 0 ? 4294967295 : data[i] >> 3 << 15 | data[i + 1] >> 3 << 10 | data[i + 2] >> 3 << 5 | a >> 6;
+    seen.add(key);
+  }
+  return { colorCount: seen.size, sampleSize: info.width * info.height };
+}
+function encoderNames() {
+  const v = sharp.versions;
+  return {
+    avif: `libaom-av1 ${v.aom ?? "unknown"}`,
+    webp: `libwebp ${v.webp ?? "unknown"}`
+  };
+}
+var LQIP_EDGE = 16;
+var BLURHASH_EDGE = 32;
+async function makePlaceholder(input, kind) {
+  switch (kind) {
+    case "dominant-color": {
+      const { dominant } = await sharp(input).rotate().stats();
+      const hex = (n) => n.toString(16).padStart(2, "0");
+      return { kind, value: `#${hex(dominant.r)}${hex(dominant.g)}${hex(dominant.b)}` };
+    }
+    case "lqip": {
+      const webp = await sharp(input).rotate().resize(LQIP_EDGE, LQIP_EDGE, { fit: "inside" }).webp({ quality: 40, effort: 6 }).toBuffer();
+      return { kind, value: `data:image/webp;base64,${webp.toString("base64")}` };
+    }
+    case "blurhash": {
+      const { data, info } = await sharp(input).rotate().resize(BLURHASH_EDGE, BLURHASH_EDGE, { fit: "inside" }).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+      const [cx, cy] = componentsFor(info.width, info.height);
+      return { kind, value: encodeBlurhash(data, info.width, info.height, cx, cy) };
+    }
+  }
+}
+var sharpImageEngine = {
+  encoders: encoderNames,
+  placeholder: makePlaceholder,
+  versions() {
+    const v = sharp.versions;
+    return { sharp: v.sharp ?? "unknown", vips: v.vips ?? "unknown" };
+  },
+  async analyze(input) {
+    const meta = await sharp(input).metadata();
+    const swap = (meta.orientation ?? 1) >= 5;
+    const width = (swap ? meta.height : meta.width) ?? 0;
+    const height = (swap ? meta.width : meta.height) ?? 0;
+    const format = sourceFormat(meta.format, meta.compression);
+    const hasAlpha = meta.hasAlpha ?? false;
+    let alphaUsed = false;
+    if (hasAlpha && format !== "other") {
+      const { channels } = await sharp(input).stats();
+      const alpha = channels[channels.length - 1];
+      alphaUsed = alpha !== void 0 && alpha.min < 255;
+    }
+    const { colorCount, sampleSize } = format === "other" ? { colorCount: 0, sampleSize: 0 } : await sampleColors(input);
+    return {
+      width,
+      height,
+      format,
+      hasAlpha,
+      alphaUsed,
+      animated: (meta.pages ?? 1) > 1,
+      space: meta.space ?? "unknown",
+      depth: meta.depth ?? "unknown",
+      colorCount,
+      sampleSize,
+      metadata: {
+        exif: meta.exif?.byteLength ?? 0,
+        xmp: meta.xmp?.byteLength ?? 0,
+        iptc: meta.iptc?.byteLength ?? 0,
+        icc: meta.icc?.byteLength ?? 0,
+        gps: meta.exif ? hasGpsIfd(meta.exif) : false
+      }
+    };
+  },
+  async decodeRaw(input, options) {
+    let image = sharp(input).rotate();
+    if (options.width) image = image.resize({ width: options.width, withoutEnlargement: true });
+    const { data, info } = await image.toColourspace("srgb").ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+    return {
+      data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+      width: info.width,
+      height: info.height,
+      channels: 4
+    };
+  },
+  async encodeRaw(image, request) {
+    const raw = sharp(image.data, {
+      raw: { width: image.width, height: image.height, channels: image.channels }
+    });
+    const encoded = request.format === "avif" ? raw.avif({ quality: request.quality, effort: request.effort }) : raw.webp({ quality: request.quality, effort: request.effort });
+    const { data, info } = await encoded.toBuffer({ resolveWithObject: true });
+    return {
+      data,
+      width: info.width,
+      height: info.height,
+      encoder: encoderNames()[request.format]
+    };
+  },
+  async encode(input, request) {
+    const meta = await sharp(input).metadata();
+    let image = sharp(input).rotate().resize({ width: request.width, withoutEnlargement: true });
+    image = meta.space === "cmyk" ? image.toColourspace("srgb") : image.keepIccProfile();
+    image = request.format === "avif" ? image.avif({
+      quality: request.quality,
+      effort: request.effort,
+      lossless: request.lossless
+    }) : image.webp({
+      quality: request.quality,
+      effort: request.effort,
+      lossless: request.lossless
+    });
+    const { data, info } = await image.toBuffer({ resolveWithObject: true });
+    return {
+      data,
+      width: info.width,
+      height: info.height,
+      encoder: encoderNames()[request.format]
+    };
+  }
+};
+
+export {
+  sharpImageEngine
+};

package/dist/chunk-YBEC5QGV.js

@@ -0,0 +1,463 @@
+#!/usr/bin/env node
+import {
+  BytecutError,
+  detectProject,
+  hint,
+  matchesGlob
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/presets/hero.ts
+var HERO_PRESET = {
+  name: "hero",
+  widths: [640, 1280, 1920, 2560],
+  formats: ["avif", "webp"],
+  encoders: {
+    avif: { quality: 65, effort: 4 },
+    webp: { quality: 82, effort: 4 }
+  },
+  priority: true
+};
+
+// src/core/presets/icon.ts
+var ICON_PRESET = {
+  name: "icon",
+  widths: [64, 128, 256, 512],
+  formats: ["avif", "webp"],
+  encoders: {
+    avif: { quality: 80, effort: 4 },
+    webp: { quality: 90, effort: 4 }
+  },
+  lossless: true
+};
+
+// src/core/presets/photo.ts
+var PHOTO_PRESET = {
+  name: "photo",
+  widths: [640, 1280, 1920],
+  formats: ["avif", "webp"],
+  encoders: {
+    avif: { quality: 60, effort: 4 },
+    webp: { quality: 78, effort: 4 }
+  }
+};
+
+// src/core/presets/index.ts
+var IMAGE_PRESETS = {
+  photo: PHOTO_PRESET,
+  hero: HERO_PRESET,
+  icon: ICON_PRESET
+};
+function getImagePreset(name, catalog) {
+  const presets = catalog?.image ?? IMAGE_PRESETS;
+  const preset = presets[name];
+  if (!preset) {
+    throw new BytecutError(
+      "BAD_ARGUMENTS",
+      `Unknown preset "${name}". Image presets: ${Object.keys(presets).join(", ")}.`
+    );
+  }
+  return preset;
+}
+
+// src/core/presets/video.ts
+var POSTER = { quality: 55, effort: 4, at: 0.1 };
+var BACKGROUND_VIDEO_PRESET = {
+  name: "background-video",
+  codecs: ["av1", "h264"],
+  audio: "strip",
+  audioBitrate: "96k",
+  maxWidth: 1920,
+  maxFps: 30,
+  crf: { av1: 38, h264: 28 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var CONTENT_VIDEO_PRESET = {
+  name: "content-video",
+  codecs: ["av1", "h264"],
+  audio: "keep",
+  audioBitrate: "128k",
+  maxWidth: null,
+  maxFps: null,
+  crf: { av1: 32, h264: 23 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var GIF_TO_VIDEO_PRESET = {
+  name: "gif-to-video",
+  codecs: ["av1", "h264"],
+  audio: "strip",
+  audioBitrate: "96k",
+  maxWidth: 1920,
+  maxFps: null,
+  crf: { av1: 36, h264: 26 },
+  speed: { av1: "6", h264: "slow" },
+  poster: POSTER
+};
+var VIDEO_PRESETS = {
+  "background-video": BACKGROUND_VIDEO_PRESET,
+  "content-video": CONTENT_VIDEO_PRESET,
+  "gif-to-video": GIF_TO_VIDEO_PRESET
+};
+function getVideoPreset(name, catalog) {
+  return (catalog?.video ?? VIDEO_PRESETS)[name];
+}
+
+// src/core/presets/catalog.ts
+var BUILTIN_CATALOG = {
+  image: IMAGE_PRESETS,
+  video: VIDEO_PRESETS,
+  root: Object.fromEntries(
+    [...Object.keys(IMAGE_PRESETS), ...Object.keys(VIDEO_PRESETS)].map((n) => [n, n])
+  ),
+  origin: {}
+};
+function rootPreset(catalog, name) {
+  return catalog?.root[name] ?? name;
+}
+var BUILTIN_POLICY = {
+  catalog: BUILTIN_CATALOG,
+  assetFor: () => void 0
+};
+
+// src/core/config/presets.ts
+var IMAGE_TARGETS = {
+  low: { avif: 45, webp: 65 },
+  balanced: { avif: 60, webp: 78 },
+  high: { avif: 75, webp: 88 }
+};
+var VIDEO_TARGET_CRF_OFFSET = { low: 4, balanced: 0, high: -4 };
+var IMAGE_ONLY = [
+  "widths",
+  "formats",
+  "quality",
+  "effort",
+  "lossless",
+  "priority",
+  "floor",
+  "maxSize"
+];
+var VIDEO_ONLY = ["audio", "maxWidth", "maxFps", "codecs", "crf"];
+var METRICS = ["ssimulacra2", "vmaf"];
+function fail(message) {
+  throw new BytecutError("CONFIG_INVALID", `presets: ${message}`);
+}
+function applyImage(name, base, def) {
+  for (const key of VIDEO_ONLY) {
+    if (def[key] !== void 0) {
+      fail(`"${name}" extends an image preset, so \`${key}\` (a video setting) does not apply.`);
+    }
+  }
+  if (def.vmaf !== void 0) {
+    fail(`"${name}" extends an image preset, so \`vmaf\` (a video metric) does not apply.`);
+  }
+  const next = {
+    ...base,
+    name,
+    widths: [...base.widths],
+    formats: [...base.formats],
+    encoders: { avif: { ...base.encoders.avif }, webp: { ...base.encoders.webp } }
+  };
+  if (def.target === "lossless") next.lossless = true;
+  else if (def.target) {
+    next.encoders.avif.quality = IMAGE_TARGETS[def.target].avif;
+    next.encoders.webp.quality = IMAGE_TARGETS[def.target].webp;
+  }
+  if (def.widths) next.widths = [...new Set(def.widths)].sort((a, b) => a - b);
+  if (def.formats) next.formats = [...new Set(def.formats)];
+  if (def.quality?.avif !== void 0) next.encoders.avif.quality = def.quality.avif;
+  if (def.quality?.webp !== void 0) next.encoders.webp.quality = def.quality.webp;
+  if (def.effort?.avif !== void 0) next.encoders.avif.effort = def.effort.avif;
+  if (def.effort?.webp !== void 0) next.encoders.webp.effort = def.effort.webp;
+  if (def.lossless !== void 0) next.lossless = def.lossless;
+  if (def.priority !== void 0) next.priority = def.priority;
+  if (def.ssimulacra2 !== void 0) {
+    next.search = {
+      metric: "ssimulacra2",
+      target: def.ssimulacra2,
+      ...def.floor !== void 0 ? { floor: def.floor } : {},
+      ...def.maxSize !== void 0 ? { maxBytes: def.maxSize } : {}
+    };
+  }
+  return next;
+}
+function applyVideo(name, base, def) {
+  for (const key of IMAGE_ONLY) {
+    if (def[key] !== void 0) {
+      fail(`"${name}" extends a video preset, so \`${key}\` (an image setting) does not apply.`);
+    }
+  }
+  if (def.target === "lossless") {
+    fail(`"${name}": \`target: "lossless"\` is not available for video; use "high".`);
+  }
+  const next = {
+    ...base,
+    name,
+    codecs: [...base.codecs],
+    crf: { ...base.crf },
+    speed: { ...base.speed },
+    poster: { ...base.poster }
+  };
+  if (def.target) {
+    const offset = VIDEO_TARGET_CRF_OFFSET[def.target];
+    next.crf = { av1: base.crf.av1 + offset, h264: base.crf.h264 + offset };
+  }
+  if (def.crf?.av1 !== void 0) next.crf.av1 = def.crf.av1;
+  if (def.crf?.h264 !== void 0) next.crf.h264 = def.crf.h264;
+  if (def.codecs) next.codecs = [...new Set(def.codecs)];
+  if (def.audio) next.audio = def.audio;
+  if (def.maxWidth !== void 0) next.maxWidth = def.maxWidth;
+  if (def.maxFps !== void 0) next.maxFps = def.maxFps;
+  if (def.ssimulacra2 !== void 0)
+    next.search = { metric: "ssimulacra2", target: def.ssimulacra2 };
+  if (def.vmaf !== void 0) next.search = { metric: "vmaf", target: def.vmaf };
+  return next;
+}
+var CHANGE_KEYS = [...IMAGE_ONLY, ...VIDEO_ONLY, ...METRICS, "target"];
+function buildCatalog(defs) {
+  const image = { ...BUILTIN_CATALOG.image };
+  const video = { ...BUILTIN_CATALOG.video };
+  const root = { ...BUILTIN_CATALOG.root };
+  const origin = {};
+  if (!defs) return { image, video, root, origin };
+  const builtinNames = new Set(Object.keys(BUILTIN_CATALOG.root));
+  const done = /* @__PURE__ */ new Set();
+  function resolve(name, stack) {
+    if (done.has(name)) return;
+    const def = defs[name];
+    if (!def) return;
+    if (stack.includes(name)) fail(`extends cycle: ${[...stack, name].join(" \u2192 ")}.`);
+    const parent = def.extends ?? (builtinNames.has(name) ? name : void 0);
+    if (parent === void 0) {
+      fail(
+        `"${name}" must say what it extends, e.g. { "extends": "photo" }. Built-ins: ${[...builtinNames].join(", ")}.`
+      );
+    }
+    if (parent === "svg") fail(`"${name}" extends "svg", which has no output yet.`);
+    if (parent === name) {
+      if (!builtinNames.has(name)) fail(`"${name}" extends itself.`);
+    } else if (defs[parent]) {
+      resolve(parent, [...stack, name]);
+    } else if (!builtinNames.has(parent)) {
+      const known = [...builtinNames, ...Object.keys(defs)];
+      fail(`"${name}" extends unknown preset "${parent}"${hint(parent, known)}.`);
+    }
+    const baseName = parent === name ? name : parent;
+    const chain = [];
+    if (parent === name) chain.push(name);
+    else chain.push(...origin[parent]?.chain ?? [parent], name);
+    if (image[baseName]) {
+      image[name] = applyImage(name, image[baseName], def);
+    } else if (video[baseName]) {
+      video[name] = applyVideo(name, video[baseName], def);
+    } else {
+      fail(`"${name}" extends "${baseName}", which is not an image or video preset.`);
+    }
+    root[name] = parent === name ? name : root[parent] ?? parent;
+    origin[name] = {
+      chain,
+      overrides: CHANGE_KEYS.filter((key) => def[key] !== void 0)
+    };
+    done.add(name);
+  }
+  for (const name of Object.keys(defs)) resolve(name, []);
+  return { image, video, root, origin };
+}
+
+// src/core/config/resolve.ts
+function resolveConfigData(config, project, loaded) {
+  const name = loaded?.name ?? "config";
+  const catalog = buildCatalog(config.presets);
+  const assets = Object.entries(config.assets ?? {}).map(([pattern, preset]) => ({
+    pattern,
+    preset
+  }));
+  for (const { pattern, preset } of assets) {
+    if (!catalog.image[preset] && !catalog.video[preset]) {
+      const known = [...Object.keys(catalog.image), ...Object.keys(catalog.video)];
+      throw new BytecutError(
+        "CONFIG_INVALID",
+        `${name}: assets["${pattern}"]: unknown preset "${preset}"${hint(preset, known)}. Known presets: ${known.join(", ")}.`
+      );
+    }
+  }
+  const rules = {};
+  for (const [id, setting] of Object.entries(config.audit?.rules ?? {})) {
+    rules[id] = setting;
+  }
+  const budgets = {};
+  if (config.budgets?.maxFileSize !== void 0) budgets.maxFileBytes = config.budgets.maxFileSize;
+  if (config.budgets?.maxTotalSize !== void 0)
+    budgets.maxTotalBytes = config.budgets.maxTotalSize;
+  return {
+    loaded,
+    project: {
+      ...project,
+      ...config.include ? { include: config.include } : {},
+      ...config.outDir ? { outDir: config.outDir } : {},
+      ...config.publicPath ? { publicPath: config.publicPath } : {}
+    },
+    provenance: {
+      framework: config.framework ? "config" : "detected",
+      include: config.include ? "config" : "detected",
+      outDir: config.outDir ? "config" : "detected",
+      publicPath: config.publicPath ? "config" : "detected"
+    },
+    exclude: config.exclude ?? [],
+    catalog,
+    policy: {
+      catalog,
+      assetFor: (source) => assets.find((rule) => matchesGlob(rule.pattern, source))
+    },
+    assets,
+    rules,
+    auditIgnore: config.audit?.ignore ?? [],
+    budgets,
+    placeholder: config.manifest?.placeholder,
+    concurrency: config.concurrency,
+    ffmpegPath: config.ffmpegPath,
+    ffprobePath: config.ffprobePath,
+    ssimulacra2Path: config.ssimulacra2Path
+  };
+}
+async function resolveConfig(projectRoot, loaded) {
+  const framework = loaded?.config.framework;
+  const project = await detectProject(projectRoot, { framework });
+  return resolveConfigData(loaded?.config ?? {}, project, loaded);
+}
+
+// src/core/ffmpeg/resolve.ts
+import { delimiter, dirname, join } from "path";
+var ENV_VAR = {
+  ffmpeg: "BYTECUT_FFMPEG",
+  ffprobe: "BYTECUT_FFPROBE",
+  ssimulacra2: "BYTECUT_SSIMULACRA2"
+};
+function executableNames(name, platform, env) {
+  if (platform !== "win32") return [name];
+  const exts = (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean);
+  return [name, ...exts.map((ext) => name + ext.toLowerCase())];
+}
+function resolveBinary(name, options, deps) {
+  const explicit = [
+    ["flag", options.flag],
+    ["env", options.env[ENV_VAR[name]]],
+    ["config", options.config]
+  ];
+  for (const [source, value] of explicit) {
+    if (value === void 0 || value === "") continue;
+    return deps.isFile(value) ? { found: true, path: value, source } : { found: false, source, attempted: value };
+  }
+  const names = executableNames(name, options.platform, options.env);
+  if (name === "ffprobe" && options.ffmpegDir) {
+    for (const candidate of names) {
+      const path = join(options.ffmpegDir, candidate);
+      if (deps.isFile(path)) return { found: true, path, source: "ffmpeg-dir" };
+    }
+  }
+  const dirs = (options.env.PATH ?? "").split(delimiter).filter(Boolean);
+  for (const dir of dirs) {
+    for (const candidate of names) {
+      const path = join(dir, candidate);
+      if (deps.isFile(path)) return { found: true, path, source: "path" };
+    }
+  }
+  return { found: false, source: null };
+}
+function ffmpegDirOf(resolved) {
+  return resolved.found ? dirname(resolved.path) : void 0;
+}
+
+// src/core/ffmpeg/capabilities.ts
+function parseVersion(output) {
+  const match = /^\w+ version (\S+)/m.exec(output);
+  return match?.[1] ?? null;
+}
+function parseListing(output, kind) {
+  const entry = kind === "encoders" ? /^\s*[VAS][A-Z.]{5}\s+(\S+)/ : /^\s*[T.][S.][C.]\s+(\S+)/;
+  const names = /* @__PURE__ */ new Set();
+  for (const line of output.split(/\r?\n/)) {
+    const name = entry.exec(line)?.[1];
+    if (name && name !== "=") names.add(name);
+  }
+  return names;
+}
+function toCapabilities(encoders, filters) {
+  return {
+    libsvtav1: encoders.has("libsvtav1"),
+    libaomAv1: encoders.has("libaom-av1"),
+    libx264: encoders.has("libx264"),
+    libvpxVp9: encoders.has("libvpx-vp9"),
+    libvmaf: filters.has("libvmaf")
+  };
+}
+function pickAv1Encoder(caps) {
+  if (caps.libsvtav1) return "libsvtav1";
+  if (caps.libaomAv1) return "libaom-av1";
+  return null;
+}
+async function probeFfmpeg(path, run, cache = /* @__PURE__ */ new Map()) {
+  const { stdout } = await run(path, ["-hide_banner", "-version"]);
+  const version = parseVersion(stdout) ?? "unknown";
+  const key = `${path}\0${version}`;
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const [encoders, filters] = await Promise.all([
+    run(path, ["-hide_banner", "-encoders"]),
+    run(path, ["-hide_banner", "-filters"])
+  ]);
+  const info = {
+    path,
+    version,
+    capabilities: toCapabilities(
+      parseListing(encoders.stdout, "encoders"),
+      parseListing(filters.stdout, "filters")
+    )
+  };
+  cache.set(key, info);
+  return info;
+}
+async function probeFfprobeVersion(path, run) {
+  const { stdout } = await run(path, ["-hide_banner", "-version"]);
+  return parseVersion(stdout) ?? "unknown";
+}
+
+// src/core/ffmpeg/install-hint.ts
+function installHint(platform, osReleaseId) {
+  switch (platform) {
+    case "darwin":
+      return "brew install ffmpeg";
+    case "win32":
+      return "winget install ffmpeg";
+    default:
+      switch (osReleaseId) {
+        case "fedora":
+        case "rhel":
+        case "centos":
+          return "sudo dnf install ffmpeg";
+        case "arch":
+        case "manjaro":
+          return "sudo pacman -S ffmpeg";
+        case "alpine":
+          return "sudo apk add ffmpeg";
+        default:
+          return "sudo apt install ffmpeg";
+      }
+  }
+}
+
+export {
+  IMAGE_PRESETS,
+  getImagePreset,
+  getVideoPreset,
+  rootPreset,
+  BUILTIN_POLICY,
+  resolveBinary,
+  ffmpegDirOf,
+  pickAv1Encoder,
+  probeFfmpeg,
+  probeFfprobeVersion,
+  installHint,
+  resolveConfigData,
+  resolveConfig
+};