bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-NAKV7HS5.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+import {
+  outputWidth,
+  toPosix
+} from "./chunk-WE7AEDVI.js";
+import {
+  BUILTIN_POLICY,
+  getVideoPreset
+} from "./chunk-YBEC5QGV.js";
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/classify/classify.ts
+var FLAT_COLOR_LIMIT = 64;
+var ICON_MAX_EDGE = 1024;
+var HERO_NAME = /(^|[^a-z])(hero|banner|cover|header|splash|masthead|jumbotron)([^a-z]|$)/i;
+var ICON_NAME = /(^|[^a-z])(icon|logo|favicon|sprite|glyph)([^a-z]|$)/i;
+function baseName(source) {
+  const name = source.slice(source.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function classify(source, a) {
+  const name = baseName(source);
+  const longEdge = Math.max(a.width, a.height);
+  const flat = a.sampleSize > 0 && a.colorCount <= FLAT_COLOR_LIMIT;
+  if (flat && longEdge <= ICON_MAX_EDGE) {
+    const named = ICON_NAME.test(name);
+    return {
+      preset: "icon",
+      confidence: named || a.alphaUsed || longEdge <= 512 ? "high" : "medium",
+      reason: `flat art (${a.colorCount} colours in sample${a.alphaUsed ? ", uses transparency" : ""}${named ? `, name "${name}"` : ""})`
+    };
+  }
+  if (!flat && ICON_NAME.test(name) && longEdge <= 256) {
+    return {
+      preset: "icon",
+      confidence: "medium",
+      reason: `small image named "${name}" (${longEdge}px)`
+    };
+  }
+  if (HERO_NAME.test(name)) {
+    return { preset: "hero", confidence: "high", reason: `name "${name}" looks like a hero image` };
+  }
+  if (a.width >= 1920 && a.width / Math.max(1, a.height) >= 1.6) {
+    return {
+      preset: "hero",
+      confidence: "medium",
+      reason: `large wide image (${a.width}x${a.height})`
+    };
+  }
+  const confident = a.colorCount > FLAT_COLOR_LIMIT * 2;
+  return {
+    preset: "photo",
+    confidence: confident ? "high" : "low",
+    reason: confident ? "continuous-tone image" : "ambiguous content; using the conservative preset"
+  };
+}
+
+// src/core/hash.ts
+import { createHash } from "crypto";
+import { createReadStream } from "fs";
+function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+function sha256File(path) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+// src/core/plan/build.ts
+import { posix, relative } from "path";
+function targetWidths(presetWidths, sourceWidth) {
+  const widths = presetWidths.filter((w) => w <= sourceWidth);
+  const largest = Math.max(...presetWidths);
+  if (sourceWidth < largest && !widths.includes(sourceWidth)) widths.push(sourceWidth);
+  return [...new Set(widths)].sort((a, b) => a - b);
+}
+function mirroredDir(source, staticRoot) {
+  const dir = posix.dirname(source);
+  if (staticRoot !== "." && staticRoot !== "") {
+    if (dir === staticRoot) return "";
+    if (dir.startsWith(`${staticRoot}/`)) return dir.slice(staticRoot.length + 1);
+  }
+  return dir === "." ? "" : dir;
+}
+var DEFAULT_PUBLIC_PATH = "/_bytecut";
+var ANIMATED_GIF_REASON = "animated GIF";
+async function buildPlan(options) {
+  const items = [];
+  const claimed = /* @__PURE__ */ new Map();
+  const staticRoot = options.staticRoot ?? ".";
+  const analyze = options.analyze ?? ((data) => options.engine.analyze(data));
+  const files = options.files.map((file) => ({ file, source: toPosix(relative(options.projectRoot, file)) })).sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+  for (const { file, source } of files) {
+    if (source.startsWith("../") || source === "..") {
+      throw new BytecutError(
+        "SOURCE_OUTSIDE_PROJECT",
+        `${file} is outside the project root (${options.projectRoot}); run bytecut from a parent folder.`
+      );
+    }
+    const data = await options.readSource(file);
+    const digest = sha256(data);
+    const base = {
+      source,
+      sourceBytes: data.byteLength,
+      sourceSha256: digest,
+      sourceWidth: 0,
+      sourceHeight: 0
+    };
+    let analysis;
+    try {
+      analysis = await analyze(data, digest);
+    } catch {
+      items.push({
+        ...base,
+        preset: "-",
+        outputs: [],
+        skip: { reason: "unreadable or corrupt image" }
+      });
+      continue;
+    }
+    const sized = { ...base, sourceWidth: analysis.width, sourceHeight: analysis.height };
+    if (analysis.format === "other") {
+      items.push({
+        ...sized,
+        preset: "-",
+        outputs: [],
+        skip: { reason: "unsupported image format" }
+      });
+      continue;
+    }
+    if (analysis.animated) {
+      const reason = analysis.format === "gif" ? `${ANIMATED_GIF_REASON} (video conversion arrives with ffmpeg support in M5)` : "animated image";
+      items.push({ ...sized, preset: "-", outputs: [], skip: { reason } });
+      continue;
+    }
+    const choice = options.choosePreset(source, analysis);
+    const { preset } = choice;
+    const dir = mirroredDir(source, staticRoot);
+    const name = posix.basename(source, posix.extname(source));
+    const outputs = [];
+    for (const width of targetWidths(preset.widths, analysis.width)) {
+      for (const format of preset.formats) {
+        const lossless = preset.lossless ?? (analysis.format === "png" && format === "webp");
+        const path = posix.join(dir, name, `${name}-${width}.${format}`);
+        const owner = claimed.get(path);
+        if (owner !== void 0) {
+          throw new BytecutError(
+            "OUTPUT_COLLISION",
+            `${source} and ${owner} would both write ${path}. Rename one of them.`
+          );
+        }
+        claimed.set(path, source);
+        outputs.push({
+          path,
+          format,
+          width,
+          lossless,
+          ...preset.encoders[format],
+          // A lossless output is exact; there is nothing to search for.
+          ...preset.search && !lossless ? { search: { ...preset.search } } : {}
+        });
+      }
+    }
+    items.push({
+      ...sized,
+      preset: preset.name,
+      classification: {
+        reason: choice.reason,
+        ...choice.confidence ? { confidence: choice.confidence } : {}
+      },
+      outputs
+    });
+  }
+  return {
+    version: 1,
+    outDir: toPosix(relative(options.projectRoot, options.outDir)) || ".",
+    publicPath: options.publicPath ?? DEFAULT_PUBLIC_PATH,
+    items
+  };
+}
+
+// src/core/classify/video.ts
+var BACKGROUND_NAME = /(^|[^a-z])(bg|background|backdrop|loop|ambient|hero|banner|header|splash|texture|cover)([^a-z]|$)/i;
+var BACKGROUND_MAX_SECONDS = 45;
+function baseName2(source) {
+  const name = source.slice(source.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(0, dot) : name;
+}
+function classifyVideo(source, probe) {
+  const name = baseName2(source);
+  const named = BACKGROUND_NAME.test(name);
+  const short = probe.durationSec > 0 && probe.durationSec <= BACKGROUND_MAX_SECONDS;
+  if (!probe.hasAudio && short) {
+    return {
+      preset: "background-video",
+      confidence: named ? "high" : "medium",
+      reason: `silent ${probe.durationSec.toFixed(0)}s clip${named ? `, name "${name}"` : ""}`
+    };
+  }
+  if (named && short && probe.hasAudio) {
+    return {
+      preset: "background-video",
+      confidence: "medium",
+      reason: `name "${name}" and ${probe.durationSec.toFixed(0)}s long; its audio track will be removed`
+    };
+  }
+  return {
+    preset: "content-video",
+    confidence: probe.hasAudio ? "high" : "low",
+    reason: probe.hasAudio ? "has an audio track, so it is treated as content" : "long silent video; keeping resolution and frame rate"
+  };
+}
+
+// src/core/plan/video.ts
+import { stat } from "fs/promises";
+import { posix as posix2, relative as relative2 } from "path";
+function skipped(source, bytes, sha, reason, extra = {}) {
+  return {
+    source,
+    sourceBytes: bytes,
+    sourceSha256: sha,
+    sourceWidth: 0,
+    sourceHeight: 0,
+    durationSec: 0,
+    fps: 0,
+    hasAudio: false,
+    videoCodec: "unknown",
+    preset: "-",
+    outputs: [],
+    skip: { reason },
+    ...extra
+  };
+}
+function plannedVideoOutputs(source, staticRoot, preset, probe) {
+  const dir = mirroredDir(source, staticRoot);
+  const name = posix2.basename(source, posix2.extname(source));
+  const width = outputWidth(probe.width, preset.maxWidth);
+  const outputs = [];
+  for (const codec of preset.codecs) {
+    outputs.push({
+      role: "video",
+      path: posix2.join(dir, name, `${name}-${width}.${codec}.mp4`),
+      codec,
+      width,
+      crf: preset.crf[codec],
+      speed: preset.speed[codec],
+      maxWidth: preset.maxWidth,
+      maxFps: preset.maxFps,
+      audio: preset.audio,
+      audioBitrate: preset.audioBitrate,
+      ...preset.search ? { search: { ...preset.search } } : {}
+    });
+  }
+  outputs.push({
+    role: "poster",
+    path: posix2.join(dir, name, `${name}-poster.avif`),
+    format: "avif",
+    width,
+    quality: preset.poster.quality,
+    effort: preset.poster.effort,
+    at: preset.poster.at
+  });
+  return outputs;
+}
+async function buildVideoItems(options) {
+  const staticRoot = options.staticRoot ?? ".";
+  const claimed = options.claimed ?? /* @__PURE__ */ new Set();
+  const items = [];
+  const files = options.files.map((file) => ({ file, source: toPosix(relative2(options.projectRoot, file)) })).sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0);
+  const caps = options.engine ? await options.engine.capabilities() : null;
+  for (const { file, source } of files) {
+    if (source.startsWith("../") || source === "..") {
+      throw new BytecutError(
+        "SOURCE_OUTSIDE_PROJECT",
+        `${file} is outside the project root (${options.projectRoot}); run bytecut from a parent folder.`
+      );
+    }
+    const [info, sha] = await Promise.all([stat(file), sha256File(file)]);
+    if (!options.engine || !caps) {
+      items.push(skipped(source, info.size, sha, `needs ffmpeg: ${options.needsFfmpeg}`));
+      continue;
+    }
+    let probe;
+    try {
+      probe = options.probe ? await options.probe(file, sha) : await options.engine.probe(file);
+    } catch {
+      items.push(skipped(source, info.size, sha, "could not be read by ffprobe"));
+      continue;
+    }
+    if (!probe || probe.width === 0 || probe.height === 0) {
+      items.push(skipped(source, info.size, sha, "no video stream"));
+      continue;
+    }
+    const media = {
+      sourceWidth: probe.width,
+      sourceHeight: probe.height,
+      durationSec: probe.durationSec,
+      fps: probe.fps,
+      hasAudio: probe.hasAudio,
+      videoCodec: probe.videoCodec
+    };
+    const policy = options.policy ?? BUILTIN_POLICY;
+    const override = options.presetOverrides?.[source];
+    const forced = override ? getVideoPreset(override, policy.catalog) : void 0;
+    const matched = policy.assetFor(source);
+    const byAssets = matched ? getVideoPreset(matched.preset, policy.catalog) : void 0;
+    let preset;
+    let why;
+    if (forced) {
+      preset = forced;
+      why = { reason: `set to ${forced.name} for this file` };
+    } else if (byAssets && matched) {
+      preset = byAssets;
+      why = {
+        reason: `set to ${byAssets.name} by assets "${matched.pattern}"`,
+        confidence: "high"
+      };
+    } else if (posix2.extname(source).toLowerCase() === ".gif") {
+      preset = getVideoPreset("gif-to-video", policy.catalog);
+      why = { reason: "animated GIF", confidence: "high" };
+    } else {
+      const verdict = classifyVideo(source, probe);
+      preset = getVideoPreset(verdict.preset, policy.catalog);
+      why = { reason: verdict.reason, confidence: verdict.confidence };
+    }
+    const outputs = plannedVideoOutputs(source, staticRoot, preset, probe);
+    for (const out of outputs) {
+      if (claimed.has(out.path)) {
+        throw new BytecutError(
+          "OUTPUT_COLLISION",
+          `${source} would write ${out.path}, which another source already writes. Rename one of them.`
+        );
+      }
+      claimed.add(out.path);
+    }
+    items.push({
+      source,
+      sourceBytes: info.size,
+      sourceSha256: sha,
+      ...media,
+      preset: preset.name,
+      classification: why,
+      outputs
+    });
+  }
+  return items;
+}
+
+export {
+  classify,
+  sha256,
+  sha256File,
+  targetWidths,
+  mirroredDir,
+  DEFAULT_PUBLIC_PATH,
+  ANIMATED_GIF_REASON,
+  buildPlan,
+  classifyVideo,
+  plannedVideoOutputs,
+  buildVideoItems
+};