bytecut 0.0.0-stage → 0.0.1

package/dist/chunk-3DBJKHOD.js

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+// src/core/video/codecs.ts
+import { open } from "fs/promises";
+function* boxes(buf, start, end) {
+  let at = start;
+  while (at + 8 <= end) {
+    let size = buf.readUInt32BE(at);
+    const type = buf.toString("latin1", at + 4, at + 8);
+    let header = 8;
+    if (size === 1) {
+      if (at + 16 > end) return;
+      size = Number(buf.readBigUInt64BE(at + 8));
+      header = 16;
+    } else if (size === 0) {
+      size = end - at;
+    }
+    if (size < header || at + size > end) return;
+    yield { type, start: at + header, end: at + size };
+    at += size;
+  }
+}
+function find(buf, parent, type) {
+  for (const box of boxes(buf, parent.start, parent.end)) if (box.type === type) return box;
+  return void 0;
+}
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+function avcCodecString(avcC) {
+  if (avcC.length < 4) return null;
+  return `avc1.${hex2(avcC[1])}${hex2(avcC[2])}${hex2(avcC[3])}`;
+}
+function av1CodecString(av1C) {
+  if (av1C.length < 4 || (av1C[0] & 128) === 0) return null;
+  const profile = av1C[1] >> 5;
+  const level = av1C[1] & 31;
+  const tier = av1C[2] >> 7 & 1;
+  const highBitdepth = av1C[2] >> 6 & 1;
+  const twelveBit = av1C[2] >> 5 & 1;
+  const depth = highBitdepth ? twelveBit ? 12 : 10 : 8;
+  return `av01.${profile}.${String(level).padStart(2, "0")}${tier ? "H" : "M"}.${String(depth).padStart(2, "0")}`;
+}
+async function readVideoCodecString(path) {
+  const file = await open(path, "r");
+  try {
+    const { size } = await file.stat();
+    const header = Buffer.alloc(16);
+    let offset = 0;
+    for (let guard = 0; guard < 64 && offset + 8 <= size; guard++) {
+      const { bytesRead } = await file.read(header, 0, 16, offset);
+      if (bytesRead < 8) return null;
+      let boxSize = header.readUInt32BE(0);
+      const type = header.toString("latin1", 4, 8);
+      let headerSize = 8;
+      if (boxSize === 1) {
+        if (bytesRead < 16) return null;
+        boxSize = Number(header.readBigUInt64BE(8));
+        headerSize = 16;
+      } else if (boxSize === 0) {
+        boxSize = size - offset;
+      }
+      if (boxSize < headerSize) return null;
+      if (type === "moov") {
+        const payload = Buffer.alloc(boxSize - headerSize);
+        await file.read(payload, 0, payload.length, offset + headerSize);
+        return codecFromMoov(payload);
+      }
+      offset += boxSize;
+    }
+    return null;
+  } finally {
+    await file.close();
+  }
+}
+function codecFromMoov(moov) {
+  const root = { start: 0, end: moov.length };
+  for (const trak of boxes(moov, root.start, root.end)) {
+    if (trak.type !== "trak") continue;
+    const mdia = find(moov, trak, "mdia");
+    if (!mdia) continue;
+    const hdlr = find(moov, mdia, "hdlr");
+    if (!hdlr || moov.toString("latin1", hdlr.start + 8, hdlr.start + 12) !== "vide") continue;
+    const minf = find(moov, mdia, "minf");
+    const stbl = minf && find(moov, minf, "stbl");
+    const stsd = stbl && find(moov, stbl, "stsd");
+    if (!stsd) continue;
+    for (const entry of boxes(moov, stsd.start + 8, stsd.end)) {
+      const childStart = entry.start + 78;
+      if (entry.type === "avc1" || entry.type === "avc3") {
+        const avcC = find(moov, { start: childStart, end: entry.end }, "avcC");
+        if (avcC) return avcCodecString(moov.subarray(avcC.start, avcC.end));
+      }
+      if (entry.type === "av01") {
+        const av1C = find(moov, { start: childStart, end: entry.end }, "av1C");
+        if (av1C) return av1CodecString(moov.subarray(av1C.start, av1C.end));
+      }
+    }
+  }
+  return null;
+}
+function fallbackAv1CodecString(width, height) {
+  const pixels = width * height;
+  const level = pixels <= 147456 ? 0 : pixels <= 278784 ? 1 : pixels <= 665856 ? 4 : pixels <= 1065024 ? 5 : pixels <= 2359296 ? 8 : pixels <= 8912896 ? 12 : 16;
+  return `av01.0.${String(level).padStart(2, "0")}M.08`;
+}
+
+export {
+  readVideoCodecString,
+  fallbackAv1CodecString
+};

package/dist/chunk-4XOB3C34.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import {
+  isFile,
+  readOsReleaseId,
+  run
+} from "./chunk-M6ZDSATP.js";
+import {
+  createFfmpegVideoEngine
+} from "./chunk-WE7AEDVI.js";
+import {
+  installHint,
+  resolveBinary,
+  resolveConfig
+} from "./chunk-YBEC5QGV.js";
+import {
+  BytecutError,
+  loadConfig
+} from "./chunk-TWI2OZJZ.js";
+
+// src/cli/shared.ts
+import { existsSync } from "fs";
+import { resolve } from "path";
+
+// src/core/quality/native.ts
+var counter = 0;
+function createNativeScorer(options) {
+  return {
+    kind: "native",
+    label: `ssimulacra2 (${options.binary})`,
+    async score(reference, distorted) {
+      const id = `${process.pid}-${counter++}`;
+      const paths = [];
+      try {
+        paths.push(
+          await options.fs.writeTemp(
+            `.bytecut-cache/tmp/${id}-a.png`,
+            await options.toPng(reference)
+          ),
+          await options.fs.writeTemp(
+            `.bytecut-cache/tmp/${id}-b.png`,
+            await options.toPng(distorted)
+          )
+        );
+        const { stdout } = await options.run(options.binary, paths);
+        const value = Number.parseFloat(stdout.trim().split(/\s+/).pop() ?? "");
+        if (!Number.isFinite(value)) {
+          throw new BytecutError(
+            "SCORER_UNAVAILABLE",
+            `${options.binary} printed something that is not a score: ${stdout.trim().slice(0, 80)}`
+          );
+        }
+        return value;
+      } finally {
+        await Promise.all(paths.map((p) => options.fs.discardTemp(p)));
+      }
+    },
+    async close() {
+    }
+  };
+}
+
+// src/core/quality/wasm.ts
+async function createWasmScorer(options = {}) {
+  let lib;
+  try {
+    lib = await import("bytecut-ssimulacra2");
+  } catch (error) {
+    throw new BytecutError(
+      "SCORER_UNAVAILABLE",
+      `The built-in SSIMULACRA2 scorer could not be loaded: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
+  const pool = lib.createPool({ size: options.size ?? 2 });
+  return {
+    kind: "wasm",
+    label: "bytecut-ssimulacra2",
+    score: (reference, distorted) => pool.score(reference, distorted),
+    close: () => pool.close()
+  };
+}
+
+// src/core/quality/select.ts
+function resolveScorerBinary(options) {
+  return resolveBinary(
+    "ssimulacra2",
+    { flag: options.flag, config: options.config, env: options.env, platform: options.platform },
+    options.deps
+  );
+}
+async function selectScorer(options) {
+  const resolved = resolveScorerBinary(options);
+  const notes = [];
+  if (resolved.found) {
+    return {
+      scorer: createNativeScorer({
+        binary: resolved.path,
+        fs: options.fs,
+        toPng: options.toPng,
+        run: options.run
+      }),
+      notes
+    };
+  }
+  if (resolved.attempted) {
+    notes.push(
+      `ssimulacra2 not found at ${resolved.attempted} (from ${resolved.source}); using the built-in WebAssembly scorer.`
+    );
+  }
+  return {
+    scorer: await createWasmScorer(options.size !== void 0 ? { size: options.size } : {}),
+    notes
+  };
+}
+
+// src/cli/shared.ts
+import { availableParallelism } from "os";
+var configArg = {
+  config: {
+    type: "string",
+    description: "Path to a config file (default: bytecut.config.{ts,js,json,toml} in the project)"
+  }
+};
+async function discover(inputs, outDirArg, configPath) {
+  const projectRoot = process.cwd();
+  const config = await resolveConfig(projectRoot, await loadConfig(projectRoot, configPath));
+  const { project } = config;
+  const scanInputs = inputs.length > 0 ? inputs : project.include.filter((p) => existsSync(resolve(projectRoot, p)));
+  return { projectRoot, project, scanInputs, outDir: outDirArg ?? project.outDir, config };
+}
+function ffmpegStatus(config) {
+  const resolved = resolveBinary(
+    "ffmpeg",
+    { env: process.env, platform: process.platform, config: config?.ffmpegPath },
+    { isFile }
+  );
+  return { found: resolved.found, installHint: installHint(process.platform, readOsReleaseId()) };
+}
+function noAssetsMessage(command, project) {
+  return `bytecut${command ? ` ${command}` : ""}: no asset folder found (looked for ${project.include.join(", ")}). Pass files or folders.`;
+}
+function createVideoEngine(flags = {}, config = {}) {
+  return createFfmpegVideoEngine({
+    ffmpegFlag: flags.ffmpeg,
+    ffprobeFlag: flags.ffprobe,
+    ffmpegConfig: config.ffmpegPath,
+    ffprobeConfig: config.ffprobePath,
+    env: process.env,
+    platform: process.platform,
+    deps: { isFile },
+    run
+  });
+}
+function makeScorerFactory(flag, config = {}) {
+  return async (fs) => {
+    const sharp = (await import("sharp")).default;
+    return selectScorer({
+      flag,
+      config: config.ssimulacra2Path,
+      env: process.env,
+      platform: process.platform,
+      deps: { isFile },
+      fs,
+      run,
+      size: Math.max(1, Math.min(4, availableParallelism() - 1)),
+      toPng: async (image) => new Uint8Array(
+        await sharp(image.data, {
+          raw: { width: image.width, height: image.height, channels: 3 }
+        }).png().toBuffer()
+      )
+    });
+  };
+}
+function ffmpegInstallText() {
+  return `install ffmpeg with: ${installHint(process.platform, readOsReleaseId())}`;
+}
+
+export {
+  configArg,
+  discover,
+  ffmpegStatus,
+  noAssetsMessage,
+  createVideoEngine,
+  makeScorerFactory,
+  ffmpegInstallText
+};

package/dist/chunk-5R7LR5BB.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import {
+  BytecutError
+} from "./chunk-TWI2OZJZ.js";
+
+// src/core/plan/schema.ts
+import { z } from "zod";
+var safeRelativePath = z.string().min(1).refine(
+  (p) => !p.startsWith("/") && !/^[A-Za-z]:/.test(p) && !p.includes("\\") && p.split("/").every((s) => s !== "" && s !== "." && s !== ".."),
+  "must be a relative POSIX path without '..' segments"
+);
+var outputSchema = z.object({
+  path: safeRelativePath,
+  format: z.enum(["avif", "webp"]),
+  width: z.number().int().positive(),
+  lossless: z.boolean(),
+  quality: z.number().int().min(1).max(100),
+  effort: z.number().int().min(0).max(9),
+  search: z.object({
+    metric: z.literal("ssimulacra2"),
+    target: z.number().min(1).max(100),
+    floor: z.number().min(1).max(100).optional(),
+    maxBytes: z.number().int().positive().optional()
+  }).strict().optional()
+}).strict();
+var itemSchema = z.object({
+  source: safeRelativePath,
+  sourceBytes: z.number().int().nonnegative(),
+  sourceSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  sourceWidth: z.number().int().nonnegative(),
+  sourceHeight: z.number().int().nonnegative(),
+  preset: z.string().min(1),
+  classification: z.object({
+    reason: z.string(),
+    confidence: z.enum(["high", "medium", "low"]).optional()
+  }).strict().optional(),
+  outputs: z.array(outputSchema),
+  skip: z.object({ reason: z.string() }).strict().optional()
+}).strict();
+var videoOutputSchema = z.discriminatedUnion("role", [
+  z.object({
+    role: z.literal("video"),
+    path: safeRelativePath,
+    codec: z.enum(["av1", "h264"]),
+    width: z.number().int().positive(),
+    crf: z.number().int().min(0).max(63),
+    speed: z.string().min(1),
+    maxWidth: z.number().int().positive().nullable(),
+    maxFps: z.number().positive().nullable(),
+    audio: z.enum(["strip", "keep"]),
+    audioBitrate: z.string().regex(/^\d+k$/),
+    search: z.object({ metric: z.enum(["ssimulacra2", "vmaf"]), target: z.number().min(1).max(100) }).strict().optional()
+  }).strict(),
+  z.object({
+    role: z.literal("poster"),
+    path: safeRelativePath,
+    format: z.literal("avif"),
+    width: z.number().int().positive(),
+    quality: z.number().int().min(1).max(100),
+    effort: z.number().int().min(0).max(9),
+    at: z.number().min(0).max(1)
+  }).strict()
+]);
+var videoItemSchema = z.object({
+  source: safeRelativePath,
+  sourceBytes: z.number().int().nonnegative(),
+  sourceSha256: z.string().regex(/^[0-9a-f]{64}$/),
+  sourceWidth: z.number().int().nonnegative(),
+  sourceHeight: z.number().int().nonnegative(),
+  durationSec: z.number().nonnegative(),
+  fps: z.number().nonnegative(),
+  hasAudio: z.boolean(),
+  videoCodec: z.string(),
+  preset: z.string().min(1),
+  classification: z.object({
+    reason: z.string(),
+    confidence: z.enum(["high", "medium", "low"]).optional()
+  }).strict().optional(),
+  outputs: z.array(videoOutputSchema),
+  skip: z.object({ reason: z.string() }).strict().optional()
+}).strict();
+var planSchema = z.object({
+  version: z.literal(1),
+  // May legitimately contain `..` (an output folder beside the project); SafeFs validates it.
+  outDir: z.string().min(1).refine((p) => !p.startsWith("/") && !/^[A-Za-z]:/.test(p) && !p.includes("\\")),
+  publicPath: z.string().min(1),
+  items: z.array(itemSchema),
+  videos: z.array(videoItemSchema).optional()
+}).strict().superRefine((plan, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  const outputs = [
+    ...plan.items.flatMap((i) => i.outputs),
+    ...(plan.videos ?? []).flatMap((v) => v.outputs)
+  ];
+  for (const out of outputs) {
+    if (seen.has(out.path)) {
+      ctx.addIssue({ code: "custom", message: `duplicate output path ${out.path}` });
+    }
+    seen.add(out.path);
+  }
+});
+function formatZodIssues(error) {
+  return error.issues.slice(0, 5).map((i) => `${i.path.join(".") || "(root)"}: ${i.message}`).join("; ");
+}
+function parsePlan(text, origin = "plan") {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new BytecutError("PLAN_INVALID", `${origin} is not valid JSON.`);
+  }
+  const result = planSchema.safeParse(json);
+  if (!result.success) {
+    throw new BytecutError(
+      "PLAN_INVALID",
+      `${origin} is not a valid bytecut plan: ${formatZodIssues(result.error)}`
+    );
+  }
+  return result.data;
+}
+function serializePlan(plan) {
+  return `${JSON.stringify(plan, null, 2)}
+`;
+}
+
+// src/core/placeholders/types.ts
+var PLACEHOLDER_KINDS = ["dominant-color", "lqip", "blurhash"];
+function isPlaceholderKind(value) {
+  return PLACEHOLDER_KINDS.includes(value);
+}
+
+// src/core/manifest/types.ts
+var MANIFEST_FILE = "bytecut-manifest.json";
+var MANIFEST_VERSION = 3;
+var MANIFEST_MIN_VERSION = 2;
+
+// src/core/manifest/io.ts
+import { z as z2 } from "zod";
+var outputSchema2 = z2.object({
+  path: z2.string().min(1),
+  url: z2.string(),
+  format: z2.enum(["avif", "webp"]),
+  width: z2.number().int().nonnegative(),
+  height: z2.number().int().nonnegative(),
+  bytes: z2.number().int().nonnegative(),
+  sha256: z2.string().regex(/^[0-9a-f]{64}$/).optional(),
+  lossless: z2.boolean(),
+  quality: z2.number().int(),
+  effort: z2.number().int(),
+  encoder: z2.string(),
+  status: z2.enum(["written", "already-optimal", "stale"]),
+  search: z2.object({
+    metric: z2.literal("ssimulacra2"),
+    target: z2.number(),
+    floor: z2.number().optional(),
+    maxBytes: z2.number().int().optional(),
+    plannedPath: z2.string().optional()
+  }).strict().optional(),
+  score: z2.number().optional(),
+  scorer: z2.enum(["wasm", "native"]).optional()
+}).strict();
+var placeholderSchema = z2.object({ kind: z2.enum(PLACEHOLDER_KINDS), value: z2.string() }).strict();
+var videoOutputSchema2 = z2.object({
+  path: z2.string().min(1),
+  url: z2.string(),
+  role: z2.enum(["video", "poster"]),
+  format: z2.enum(["mp4", "avif"]),
+  codec: z2.enum(["av1", "h264"]).optional(),
+  width: z2.number().int().nonnegative(),
+  height: z2.number().int().nonnegative(),
+  fps: z2.number().nonnegative().optional(),
+  bytes: z2.number().int().nonnegative(),
+  sha256: z2.string().regex(/^[0-9a-f]{64}$/).optional(),
+  crf: z2.number().int().optional(),
+  speed: z2.string().optional(),
+  maxWidth: z2.number().int().nullable().optional(),
+  maxFps: z2.number().nullable().optional(),
+  audio: z2.enum(["strip", "keep"]).optional(),
+  quality: z2.number().int().optional(),
+  effort: z2.number().int().optional(),
+  at: z2.number().optional(),
+  codecs: z2.string().optional(),
+  encoder: z2.string(),
+  status: z2.enum(["written", "already-optimal", "stale"]),
+  search: z2.object({ metric: z2.enum(["ssimulacra2", "vmaf"]), target: z2.number() }).strict().optional(),
+  score: z2.number().optional(),
+  scorer: z2.enum(["wasm", "native", "libvmaf"]).optional()
+}).strict();
+var manifestSchema = z2.object({
+  version: z2.union([z2.literal(2), z2.literal(3)]),
+  tools: z2.record(z2.string(), z2.string()),
+  publicPath: z2.string(),
+  sources: z2.record(
+    z2.string(),
+    z2.object({
+      sha256: z2.string().regex(/^[0-9a-f]{64}$/),
+      bytes: z2.number().int().nonnegative(),
+      width: z2.number().int().nonnegative(),
+      height: z2.number().int().nonnegative(),
+      preset: z2.string(),
+      priority: z2.boolean().optional(),
+      placeholder: placeholderSchema.optional(),
+      outputs: z2.array(outputSchema2)
+    }).strict()
+  ),
+  // Absent in version 2.
+  videos: z2.record(
+    z2.string(),
+    z2.object({
+      sha256: z2.string().regex(/^[0-9a-f]{64}$/),
+      bytes: z2.number().int().nonnegative(),
+      width: z2.number().int().nonnegative(),
+      height: z2.number().int().nonnegative(),
+      durationSec: z2.number().nonnegative(),
+      preset: z2.string(),
+      priority: z2.boolean().optional(),
+      placeholder: placeholderSchema.optional(),
+      outputs: z2.array(videoOutputSchema2)
+    }).strict()
+  ).optional()
+}).strict();
+function parseManifest(text) {
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch {
+    throw new BytecutError(
+      "MANIFEST_INVALID",
+      "bytecut-manifest.json is not valid JSON. Fix or delete it (outputs are regenerated from sources)."
+    );
+  }
+  const version = json?.version;
+  if (typeof version === "number" && version < MANIFEST_MIN_VERSION) {
+    throw new BytecutError(
+      "MANIFEST_OUTDATED",
+      `bytecut-manifest.json is version ${version}, written by a pre-release bytecut with an older output layout. Delete the output folder and re-run to regenerate it.`
+    );
+  }
+  if (typeof version === "number" && version > MANIFEST_VERSION) {
+    throw new BytecutError(
+      "MANIFEST_UNSUPPORTED",
+      `bytecut-manifest.json is version ${version}, but this bytecut understands up to ${MANIFEST_VERSION}. Upgrade bytecut.`
+    );
+  }
+  const result = manifestSchema.safeParse(json);
+  if (!result.success) {
+    throw new BytecutError(
+      "MANIFEST_INVALID",
+      `bytecut-manifest.json is not a valid manifest: ${formatZodIssues(result.error)}`
+    );
+  }
+  return {
+    ...result.data,
+    version: MANIFEST_VERSION,
+    videos: result.data.videos ?? {}
+  };
+}
+function serializeManifest(manifest) {
+  const sorted = {
+    version: manifest.version,
+    tools: Object.fromEntries(Object.entries(manifest.tools).sort(([a], [b]) => a < b ? -1 : 1)),
+    publicPath: manifest.publicPath,
+    sources: Object.fromEntries(
+      Object.entries(manifest.sources).sort(([a], [b]) => a < b ? -1 : 1)
+    ),
+    videos: Object.fromEntries(
+      Object.entries(manifest.videos).sort(([a], [b]) => a < b ? -1 : 1)
+    )
+  };
+  return `${JSON.stringify(sorted, null, 2)}
+`;
+}
+
+export {
+  parsePlan,
+  serializePlan,
+  isPlaceholderKind,
+  MANIFEST_FILE,
+  MANIFEST_VERSION,
+  parseManifest,
+  serializeManifest
+};