bytecut 0.2.1 → 0.3.0

package/dist/{chunk-HLBNRB3S.js → chunk-GNW3OK5U.js}

@@ -7,7 +7,7 @@ import {
   MANIFEST_VERSION,
   parseManifest,
   serializeManifest
-} from "./chunk-TCQFQ354.js";
+} from "./chunk-CSDZGNUN.js";
 import {
   ANIMATED_GIF_REASON,
   DEFAULT_PUBLIC_PATH,
@@ -16,20 +16,20 @@ import {
   classify,
   sha256,
   sha256File
-} from "./chunk-RZ2V4PCS.js";
+} from "./chunk-JMMXC5UA.js";
 import {
   AbortedError,
   outputWidth
-} from "./chunk-QOG2F4SF.js";
+} from "./chunk-L5HLKZDW.js";
 import {
   BUILTIN_POLICY,
   IMAGE_PRESETS,
   getImagePreset,
   pickAv1Encoder
-} from "./chunk-3PF6BBFK.js";
+} from "./chunk-PE5NKZCH.js";
 import {
   SafeFs
-} from "./chunk-IZ4JEL3Q.js";
+} from "./chunk-4AM2CCML.js";
 import {
   BytecutError,
   PROJECT_RULES,
@@ -39,7 +39,7 @@ import {
   percentChange,
   plural,
   recordedByPlannedPath
-} from "./chunk-FY53B4NB.js";
+} from "./chunk-KJK7XGWA.js";
 
 // src/core/commands/optimize.ts
 import { stat as stat3 } from "fs/promises";
@@ -149,6 +149,7 @@ import { stat } from "fs/promises";
 import { resolve } from "path";
 
 // src/core/quality/video-search.ts
+var evenDown = (n) => Math.max(2, Math.floor(n / 2) * 2);
 var CLIP_SECONDS = 2;
 var WHOLE_MAX_SECONDS = 6;
 var CLIP_POINTS = [0.2, 0.5, 0.8];
@@ -160,6 +161,13 @@ var CRF_RANGE = {
 };
 var MAX_CONFIRM_BUMPS = 3;
 var CONFIRM_STEP = 2;
+var WIDTH_STEP = 0.8;
+var MIN_WIDTH_FRACTION = 0.5;
+function stepWidth(plannedWidth, width) {
+  const next = evenDown(width * WIDTH_STEP);
+  const half = Math.ceil(plannedWidth * MIN_WIDTH_FRACTION);
+  return next < half || next >= width ? null : next;
+}
 function clipsFor(durationSec) {
   if (durationSec <= WHOLE_MAX_SECONDS) {
     return { clips: [{ startSec: 0, durationSec }], whole: true };
@@ -172,7 +180,6 @@ function clipsFor(durationSec) {
   }));
   return { clips, whole: false };
 }
-var evenDown = (n) => Math.max(2, Math.floor(n / 2) * 2);
 function scoreGeometry(probe, maxWidth) {
   const out = outputWidth(probe.width, maxWidth);
   const width = evenDown(Math.min(SCORE_WIDTH, out));
@@ -214,6 +221,28 @@ async function findCrf(options) {
   }
   return { ok: true, crf: good, score: scores.get(good), probes: scores.size };
 }
+async function fitCrfToSize(options) {
+  const sizes = /* @__PURE__ */ new Map();
+  const size = async (crf) => {
+    const known = sizes.get(crf);
+    if (known !== void 0) return known;
+    const bytes = await options.sizeAt(crf);
+    sizes.set(crf, bytes);
+    return bytes;
+  };
+  const first = await size(options.lo);
+  if (first <= options.maxBytes) return { ok: true, crf: options.lo, bytes: first };
+  const last = await size(options.hi);
+  if (last > options.maxBytes) return { ok: false, crf: options.hi, bytes: last };
+  let bad = options.lo;
+  let good = options.hi;
+  while (good - bad > 1) {
+    const mid = Math.floor((bad + good) / 2);
+    if (await size(mid) <= options.maxBytes) good = mid;
+    else bad = mid;
+  }
+  return { ok: true, crf: good, bytes: sizes.get(good) };
+}
 var mean = (values) => values.reduce((a, b) => a + b, 0) / values.length;
 function createVideoSearcher(request) {
   const { clips, whole } = clipsFor(request.probe.durationSec);
@@ -276,8 +305,20 @@ function createVideoSearcher(request) {
     request.onProbe?.(crf, score);
     return score;
   }
+  async function sizeAt(crf) {
+    const bytes = await Promise.all(
+      clips.map((clip) => request.engine.sampleBytes(sample(clip, crf), request.signal))
+    );
+    const total = bytes.reduce((a, b) => a + b, 0);
+    const seconds = clips.reduce((a, c) => a + c.durationSec, 0);
+    return Math.round(
+      whole ? total : total / Math.max(1e-3, seconds) * request.probe.durationSec
+    );
+  }
   return {
     whole,
+    score: measure,
+    sizeAt,
     async find() {
       const range = CRF_RANGE[request.codec];
       return findCrf({
@@ -331,10 +372,12 @@ function probeFromItem(item) {
 }
 var evenHeight = (probe, width) => Math.max(2, Math.round(probe.height * width / Math.max(1, probe.width) / 2) * 2);
 function sameParams(planned, r) {
-  if (planned.role !== r.role || planned.width !== r.width) return false;
+  if (planned.role !== r.role) return false;
+  const stepped = r.search?.plannedPath !== void 0;
+  if (stepped ? r.width > planned.width : planned.width !== r.width) return false;
   if (planned.role === "video") {
     const search = planned.search;
-    const sameSearch = search === void 0 ? r.search === void 0 && r.crf === planned.crf : r.search?.metric === search.metric && r.search.target === search.target;
+    const sameSearch = search === void 0 ? r.search === void 0 && r.crf === planned.crf : r.search?.metric === search.metric && r.search.target === search.target && r.search.floor === search.floor && r.search.maxBytes === search.maxBytes;
     return sameSearch && 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;
@@ -382,7 +425,7 @@ async function runVideoItem(item, ctx) {
     if (!encoderFor(codec, caps)) unavailable.add(codec);
   }
   const entry = ctx.manifest?.videos[item.source];
-  const recorded = new Map((entry?.outputs ?? []).map((o) => [o.path, o]));
+  const recorded = new Map((entry?.outputs ?? []).map((o) => [o.search?.plannedPath ?? o.path, o]));
   const sameSource = entry?.sha256 === item.sourceSha256;
   const probe = probeFromItem(item);
   const versions = await ctx.engine.versions();
@@ -397,7 +440,9 @@ async function runVideoItem(item, ctx) {
   const searchable = (metric) => metric === "vmaf" ? caps.libvmaf : ctx.quality !== void 0;
   const retrySearch = /* @__PURE__ */ new Set();
   for (const r of entry?.outputs ?? []) {
-    if (r.search && r.score === void 0 && searchable(r.search.metric)) retrySearch.add(r.path);
+    if (r.search && r.score === void 0 && searchable(r.search.metric)) {
+      retrySearch.add(r.search.plannedPath ?? r.path);
+    }
   }
   const noForce = !ctx.force;
   if (noForce && retrySearch.size === 0) {
@@ -423,7 +468,7 @@ async function runVideoItem(item, ctx) {
     }
     const prior = recorded.get(planned.path);
     if (noForce && sameSource && prior && prior.status === "written" && !retrySearch.has(planned.path) && sameParams(planned, prior)) {
-      const actual = await hashOutput(planned.path);
+      const actual = await hashOutput(prior.path);
       if (actual !== null && actual === prior.sha256) {
         record(fromRecorded(prior));
         continue;
@@ -536,7 +581,7 @@ async function existingPolicy(path, newHash, ctx) {
 }
 var SEARCH_SHARE = 0.4;
 var EXPECTED_PROBES = 7;
-async function searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf, ctx) {
+async function searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf, ctx, maxWidth) {
   const search = planned.search;
   if (!search) return { kind: "fixed", skipped: false };
   const skip = (why) => {
@@ -554,7 +599,7 @@ async function searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf,
       return skip(`the quality scorer could not start (${message(error)})`);
     }
   }
-  const { width, height } = scoreGeometry(probe, planned.maxWidth);
+  const { width, height } = scoreGeometry(probe, maxWidth);
   if (search.metric === "ssimulacra2" && (width < 8 || height < 8)) {
     return skip("the video is too small to score");
   }
@@ -568,7 +613,7 @@ async function searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf,
     codec: planned.codec,
     encoder,
     speed: planned.speed,
-    maxWidth: planned.maxWidth,
+    maxWidth,
     maxFps: planned.maxFps,
     startCrf: planned.crf,
     signal: ctx.signal,
@@ -589,35 +634,116 @@ async function searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf,
       reason: `${search.metric} reached only ${outcome.bestScore.toFixed(1)} at crf ${CRF_RANGE[planned.codec].lo}, below the target ${search.target}`
     };
   }
-  return {
+  const found = {
     kind: "found",
     crf: outcome.crf,
+    qualityCrf: outcome.crf,
     score: outcome.score,
     scorer: search.metric === "vmaf" ? "libvmaf" : scorer.kind,
     searcher
   };
+  if (search.maxBytes === void 0) return found;
+  const cap = search.maxBytes;
+  const audioBytes = planned.audio === "keep" && probe.hasAudio ? Math.round(Number.parseInt(planned.audioBitrate, 10) * 1e3 / 8 * probe.durationSec) : 0;
+  const range = CRF_RANGE[planned.codec];
+  const fit = await fitCrfToSize({
+    lo: outcome.crf,
+    hi: range.hi,
+    maxBytes: Math.max(0, cap - audioBytes),
+    sizeAt: (crf) => searcher.sizeAt(crf)
+  });
+  if (!fit.ok) {
+    return {
+      kind: "too-big",
+      reason: `about ${formatBytes(fit.bytes + audioBytes)} at crf ${fit.crf}, over the ${formatBytes(cap)} cap`
+    };
+  }
+  if (fit.crf === outcome.crf) return found;
+  const floor = search.floor ?? search.target;
+  const score = await searcher.score(fit.crf);
+  if (score < floor) {
+    return {
+      kind: "too-big",
+      reason: `fitting ${formatBytes(cap)} needs crf ${fit.crf}, which scores ${score.toFixed(1)}, below the floor ${floor}`
+    };
+  }
+  return { ...found, crf: fit.crf, score };
 }
 async function makeVideo(planned, item, sourcePath, probe, encoder, hasLibvmaf, ctx, encoderLabel) {
-  const searched = await searchCrf(planned, item, sourcePath, probe, encoder, hasLibvmaf, ctx);
+  const unmet = (reason) => {
+    ctx.warnings.add(`${planned.path}: ${reason}; nothing was written`);
+    return {
+      output: { ...blank(planned, "unmet"), codec: planned.codec, error: reason },
+      wrote: false
+    };
+  };
+  let width = planned.width;
+  let maxWidth = planned.maxWidth;
+  const tried = [];
+  for (; ; ) {
+    const attempt = await attemptWidth(
+      planned,
+      item,
+      sourcePath,
+      probe,
+      encoder,
+      hasLibvmaf,
+      ctx,
+      encoderLabel,
+      width,
+      maxWidth
+    );
+    if (attempt.kind === "done") return attempt;
+    tried.push(`${width}px: ${attempt.reason}`);
+    const next = stepWidth(planned.width, width);
+    if (next === null) {
+      const half = Math.ceil(planned.width / 2);
+      return unmet(
+        `the size cap could not be met at ${width}px, the narrowest allowed (half of ${planned.width}px is ${half}px): ${tried.join("; ")}`
+      );
+    }
+    width = next;
+    maxWidth = next;
+  }
+}
+async function attemptWidth(planned, item, sourcePath, probe, encoder, hasLibvmaf, ctx, encoderLabel, width, maxWidth) {
+  const stepped = width !== planned.width;
+  const path = stepped ? planned.path.replace(
+    new RegExp(`-${planned.width}\\.${planned.codec}\\.mp4$`),
+    `-${width}.${planned.codec}.mp4`
+  ) : planned.path;
+  const searched = await searchCrf(
+    planned,
+    item,
+    sourcePath,
+    probe,
+    encoder,
+    hasLibvmaf,
+    ctx,
+    maxWidth
+  );
   if (searched.kind === "unmet") {
-    ctx.warnings.add(`${planned.path}: ${searched.reason}; nothing was written`);
+    ctx.warnings.add(`${path}: ${searched.reason}; nothing was written`);
     return {
-      output: {
-        ...blank(planned, "unmet"),
-        codec: planned.codec,
-        error: searched.reason
-      },
+      kind: "done",
+      output: { ...blank(planned, "unmet"), codec: planned.codec, error: searched.reason },
       wrote: false
     };
   }
+  if (searched.kind === "too-big") return { kind: "too-big", reason: searched.reason };
   const found = searched.kind === "found" ? searched : null;
+  const search = planned.search;
+  const cap = search?.maxBytes;
   const range = CRF_RANGE[planned.codec];
   let crf = found ? found.crf : planned.crf;
   let score = found?.score;
   const base = found ? SEARCH_SHARE : 0;
-  const temp = await ctx.fs.reserveTemp(planned.path);
+  const capped = found !== null && cap !== void 0;
+  const triedCrfs = /* @__PURE__ */ new Set();
+  const temp = await ctx.fs.reserveTemp(path);
   try {
     for (let bumps = 0; ; bumps++) {
+      triedCrfs.add(crf);
       await ctx.engine.encode(
         {
           source: sourcePath,
@@ -625,7 +751,7 @@ async function makeVideo(planned, item, sourcePath, probe, encoder, hasLibvmaf,
           encoder,
           crf,
           speed: planned.speed,
-          maxWidth: planned.maxWidth,
+          maxWidth,
           maxFps: planned.maxFps,
           audio: planned.audio,
           audioBitrate: planned.audioBitrate,
@@ -634,61 +760,83 @@ async function makeVideo(planned, item, sourcePath, probe, encoder, hasLibvmaf,
         (fraction) => ctx.onProgress?.(item.source, planned.path, base + (1 - base) * fraction),
         ctx.signal ?? new AbortController().signal
       );
+      const { size: encodedBytes } = await stat(temp);
+      if (capped && encodedBytes > cap) {
+        const nextCrf = crf + CONFIRM_STEP;
+        if (bumps >= MAX_CONFIRM_BUMPS || nextCrf > range.hi || triedCrfs.has(nextCrf)) {
+          await ctx.fs.discardTemp(temp);
+          return {
+            kind: "too-big",
+            reason: `${formatBytes(encodedBytes)} on the full encode at crf ${crf}, over the ${formatBytes(cap)} cap`
+          };
+        }
+        crf = nextCrf;
+        continue;
+      }
       if (!found || found.searcher.whole) break;
       const measured = await found.searcher.confirm(temp, crf);
-      if (measured >= planned.search.target) {
+      const required = capped && crf > found.qualityCrf ? search.floor ?? search.target : search.target;
+      if (measured >= required) {
         score = measured;
         break;
       }
-      if (bumps >= MAX_CONFIRM_BUMPS || crf - CONFIRM_STEP < range.lo) {
+      const lower = crf - CONFIRM_STEP;
+      if (bumps >= MAX_CONFIRM_BUMPS || lower < range.lo || triedCrfs.has(lower)) {
         await ctx.fs.discardTemp(temp);
-        const reason = `${planned.search.metric} was ${measured.toFixed(1)} on the full encode at crf ${crf}, below the target ${planned.search.target}`;
-        ctx.warnings.add(`${planned.path}: ${reason}; nothing was written`);
+        const reason = `${search.metric} was ${measured.toFixed(1)} on the full encode at crf ${crf}, below ${capped && crf > found.qualityCrf ? "the floor" : "the target"} ${required}`;
+        if (capped) return { kind: "too-big", reason };
+        ctx.warnings.add(`${path}: ${reason}; nothing was written`);
         return {
+          kind: "done",
           output: { ...blank(planned, "unmet"), codec: planned.codec, error: reason },
           wrote: false
         };
       }
-      crf -= CONFIRM_STEP;
+      crf = lower;
     }
     const { size } = await stat(temp);
     const video = await readVideoCodecString(temp).catch(() => null);
     const codecs = video ? planned.audio === "keep" && probe.hasAudio ? `${video}, mp4a.40.2` : video : void 0;
     const fps = planned.maxFps !== null ? Math.min(probe.fps, planned.maxFps) : probe.fps;
     const result = {
-      path: planned.path,
+      path,
       role: "video",
       format: "mp4",
       codec: planned.codec,
-      width: planned.width,
-      height: evenHeight(probe, planned.width),
+      width,
+      height: evenHeight(probe, width),
       fps: Math.round(fps * 100) / 100,
       bytes: size,
       crf,
       speed: planned.speed,
+      // The plan's own values: they are what the cache compares, whatever width was reached.
       maxWidth: planned.maxWidth,
       maxFps: planned.maxFps,
       audio: planned.audio,
       ...codecs ? { codecs } : {},
       // Recorded even when the search could not run, so the cache recognises the output; a
       // missing score is what marks it as worth searching once the metric is available.
-      ...planned.search ? { search: planned.search } : {},
+      ...search ? { search: { ...search, ...stepped ? { plannedPath: planned.path } : {} } } : {},
       ...score !== void 0 && found ? { score: Math.round(score * 100) / 100, scorer: found.scorer } : {},
       encoder: encoderLabel(encoder),
       status: "written"
     };
     if (size >= item.sourceBytes) {
       await ctx.fs.discardTemp(temp);
-      return { output: { ...result, status: "already-optimal" }, wrote: true };
+      return { kind: "done", output: { ...result, status: "already-optimal" }, wrote: true };
     }
     const digest = await sha256File(temp);
-    const verdict = await existingPolicy(planned.path, digest, ctx);
+    const verdict = await existingPolicy(path, digest, ctx);
     if (verdict) {
       await ctx.fs.discardTemp(temp);
-      return { output: { ...result, sha256: digest, status: verdict }, wrote: false };
+      return {
+        kind: "done",
+        output: { ...result, sha256: digest, status: verdict },
+        wrote: false
+      };
     }
-    await ctx.fs.commitTemp(temp, planned.path);
-    return { output: { ...result, sha256: digest }, wrote: true };
+    await ctx.fs.commitTemp(temp, path);
+    return { kind: "done", output: { ...result, sha256: digest }, wrote: true };
   } catch (error) {
     await ctx.fs.discardTemp(temp);
     throw error;
@@ -807,7 +955,7 @@ function crop(image, w) {
 // src/core/quality/search.ts
 var MAX_BUMPS = 8;
 var STEP = 0.9;
-var MIN_WIDTH_FRACTION = 0.5;
+var MIN_WIDTH_FRACTION2 = 0.5;
 var even = (n) => Math.max(2, Math.floor(n / 2) * 2);
 var kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
 var Cancelled = class extends Error {
@@ -959,7 +1107,7 @@ async function searchQuality(request) {
     const widthNotes = [];
     while (!last.ok && last.kind === "size") {
       const next = even(width * STEP);
-      const halfWidth = Math.ceil(request.width * MIN_WIDTH_FRACTION);
+      const halfWidth = Math.ceil(request.width * MIN_WIDTH_FRACTION2);
       if (next <= request.minWidth || next < halfWidth || next >= width) {
         const stoppedAt = next <= request.minWidth ? `the next planned width (${request.minWidth}px)` : `half the planned width (${halfWidth}px)`;
         return {
@@ -1386,7 +1534,12 @@ function mergeVideoItem(old, item, plannedPaths, publicPath) {
   const merged = new Map(produced);
   for (const previous of old?.outputs ?? []) {
     if (merged.has(previous.path)) continue;
-    if (plannedPaths.has(previous.path) && !sameSource) {
+    const standsFor = previous.search?.plannedPath;
+    if (standsFor !== void 0 && merged.has(standsFor)) {
+      const { plannedPath: _superseded, ...search } = previous.search;
+      void _superseded;
+      merged.set(previous.path, { ...previous, search });
+    } else if (plannedPaths.has(standsFor ?? previous.path) && !sameSource) {
       merged.set(previous.path, { ...previous, status: "stale" });
     } else {
       merged.set(previous.path, previous);
@@ -1926,7 +2079,7 @@ function formatPlan(plan, cache) {
     for (const out of video.outputs) {
       if (out.role === "video") {
         const audio = out.audio === "strip" ? "no audio" : `audio ${out.audioBitrate}`;
-        const mode = out.search ? `${out.search.metric} >= ${out.search.target} (starts at crf ${out.crf})` : `crf ${out.crf}`;
+        const mode = out.search ? `${out.search.metric} >= ${out.search.target}${out.search.maxBytes !== void 0 ? `, <= ${formatBytes(out.search.maxBytes)}` : ""} (starts at crf ${out.crf})` : `crf ${out.crf}`;
         lines.push(`  ${out.path}  (${out.codec}, ${out.width}w, ${mode}, ${audio})`);
       } else {
         lines.push(`  ${out.path}  (poster, ${out.width}w)`);
@@ -1978,7 +2131,8 @@ function searchNote(out) {
 }
 function videoSearchNote(out) {
   if (!out.search || out.score === void 0 || out.crf === void 0) return "";
-  return `  \xB7 crf ${out.crf} \xB7 ${out.search.metric} ${out.score.toFixed(1)}`;
+  const stepped = out.search.plannedPath ? " \xB7 width stepped down" : "";
+  return `  \xB7 crf ${out.crf} \xB7 ${out.search.metric} ${out.score.toFixed(1)}${stepped}`;
 }
 function videoOutputLine(out, sourceBytes) {
   const label = out.role === "poster" ? "poster" : out.codec ?? "mp4";

package/dist/{chunk-RZ2V4PCS.js → chunk-JMMXC5UA.js}

@@ -2,14 +2,14 @@
 import {
   outputWidth,
   toPosix
-} from "./chunk-QOG2F4SF.js";
+} from "./chunk-L5HLKZDW.js";
 import {
   BUILTIN_POLICY,
   getVideoPreset
-} from "./chunk-3PF6BBFK.js";
+} from "./chunk-PE5NKZCH.js";
 import {
   BytecutError
-} from "./chunk-FY53B4NB.js";
+} from "./chunk-KJK7XGWA.js";
 
 // src/core/classify/classify.ts
 var FLAT_COLOR_LIMIT = 64;

package/dist/{chunk-FY53B4NB.js → chunk-KJK7XGWA.js}

@@ -399,7 +399,7 @@ var orphanedOutput = {
       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)) {
+        if (!wanted.has(out.path) && !wanted.has(out.search?.plannedPath ?? "")) {
           findings.push({
             ruleId: ID10,
             severity: "info",
@@ -581,20 +581,29 @@ async function checkCache(item, entry, hashOutput) {
   }
   return { kind: "hit" };
 }
+function recordedVideoByPlannedPath(entry) {
+  return new Map(entry.outputs.map((o) => [o.search?.plannedPath ?? o.path, o]));
+}
 function sameVideoParams(planned, r) {
-  if (planned.role !== r.role || planned.path !== r.path || planned.width !== r.width) return false;
+  if (planned.role !== r.role) 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;
+    if (r.search?.plannedPath !== void 0) {
+      if (r.search.plannedPath !== planned.path || r.width > planned.width) return false;
+    } else if (planned.path !== r.path || planned.width !== r.width) {
+      return false;
+    }
+    const sameSearch2 = search === void 0 ? r.search === void 0 && r.crf === planned.crf : r.search?.metric === search.metric && r.search.target === search.target && r.search.floor === search.floor && r.search.maxBytes === search.maxBytes;
     return sameSearch2 && r.codec === planned.codec && r.speed === planned.speed && r.maxWidth === planned.maxWidth && r.maxFps === planned.maxFps && r.audio === planned.audio;
   }
+  if (planned.path !== r.path || planned.width !== r.width) return false;
   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 recorded = recordedVideoByPlannedPath(entry);
   const wanted = item.outputs.filter((o) => !(o.role === "video" && unavailable.has(o.codec)));
   for (const planned of wanted) {
     const r = recorded.get(planned.path);
@@ -604,7 +613,7 @@ async function checkVideoCache(item, entry, hashOutput, unavailable = /* @__PURE
     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);
+    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" };
   }
@@ -1032,7 +1041,7 @@ var presetSchema = z.object({
   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)
+  // perceptual search: images and video; `floor` and `maxSize` cap a file's size (both)
   ssimulacra2: z.number().min(1).max(100).optional(),
   vmaf: z.number().min(1).max(100).optional(),
   floor: z.number().min(1).max(100).optional(),
@@ -1050,16 +1059,18 @@ var presetSchema = z.object({
   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) {
+  const target = preset.ssimulacra2 ?? preset.vmaf;
+  const metric = preset.ssimulacra2 !== void 0 ? "ssimulacra2" : "vmaf";
+  if (preset.floor !== void 0 && target === void 0) {
     say(
       "floor",
-      "needs `ssimulacra2`: it is the lowest score allowed when `maxSize` forces quality down"
+      "needs `ssimulacra2` (or `vmaf` on a video preset): it is the lowest score allowed when `maxSize` forces quality down"
     );
   }
-  if (preset.maxSize !== void 0 && preset.ssimulacra2 === void 0) {
+  if (preset.maxSize !== void 0 && target === void 0) {
     say(
       "maxSize",
-      "needs `ssimulacra2`, so there is a quality target to hold while fitting the size"
+      "needs `ssimulacra2` (or `vmaf` on a video preset), so there is a quality target to hold while fitting the size"
     );
   }
   if (preset.maxSize !== void 0 && preset.floor === void 0) {
@@ -1068,10 +1079,10 @@ var presetSchema = z.object({
       "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 && target !== void 0 && preset.floor > target) {
+    say("floor", `must not exceed \`${metric}\` (${target})`);
   }
-  if (preset.floor !== void 0 && preset.maxSize === void 0 && preset.ssimulacra2 !== void 0) {
+  if (preset.floor !== void 0 && preset.maxSize === void 0 && target !== void 0) {
     say("floor", "only applies with `maxSize`");
   }
 });

package/dist/{chunk-QOG2F4SF.js → chunk-L5HLKZDW.js}

@@ -3,10 +3,10 @@ import {
   ffmpegDirOf,
   probeFfmpeg,
   resolveBinary
-} from "./chunk-3PF6BBFK.js";
+} from "./chunk-PE5NKZCH.js";
 import {
   BytecutError
-} from "./chunk-FY53B4NB.js";
+} from "./chunk-KJK7XGWA.js";
 
 // src/core/posix.ts
 import { sep } from "path";

package/dist/{chunk-MV6J66AP.js → chunk-MUE3L5XT.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   BytecutError
-} from "./chunk-FY53B4NB.js";
+} from "./chunk-KJK7XGWA.js";
 
 // src/cli/errors.ts
 function guarded(run) {

package/dist/{chunk-SKANYRVT.js → chunk-NOTYXNMY.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "bytecut",
-  version: "0.2.1",
+  version: "0.3.0",
   description: "Audit and optimize images and videos in web projects.",
   type: "module",
   license: "MIT",

package/dist/{chunk-3PF6BBFK.js → chunk-PE5NKZCH.js}

@@ -4,7 +4,7 @@ import {
   detectProject,
   hint,
   matchesGlob
-} from "./chunk-FY53B4NB.js";
+} from "./chunk-KJK7XGWA.js";
 
 // src/core/presets/photo.ts
 var OTHER_ENCODERS = {
@@ -146,9 +146,7 @@ var IMAGE_ONLY = [
   "quality",
   "effort",
   "lossless",
-  "priority",
-  "floor",
-  "maxSize"
+  "priority"
 ];
 var VIDEO_ONLY = ["audio", "maxWidth", "maxFps", "codecs", "crf"];
 var METRICS = ["ssimulacra2", "vmaf"];
@@ -235,12 +233,24 @@ function applyVideo(name, base, def) {
   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 };
+  const cap = {
+    ...def.floor !== void 0 ? { floor: def.floor } : {},
+    ...def.maxSize !== void 0 ? { maxBytes: def.maxSize } : {}
+  };
+  if (def.ssimulacra2 !== void 0) {
+    next.search = { metric: "ssimulacra2", target: def.ssimulacra2, ...cap };
+  }
+  if (def.vmaf !== void 0) next.search = { metric: "vmaf", target: def.vmaf, ...cap };
   return next;
 }
-var CHANGE_KEYS = [...IMAGE_ONLY, ...VIDEO_ONLY, ...METRICS, "target"];
+var CHANGE_KEYS = [
+  ...IMAGE_ONLY,
+  ...VIDEO_ONLY,
+  ...METRICS,
+  "floor",
+  "maxSize",
+  "target"
+];
 function buildCatalog(defs) {
   const image = { ...BUILTIN_CATALOG.image };
   const video = { ...BUILTIN_CATALOG.video };