bytecut 0.0.0-stage → 0.1.0

package/dist/chunk-IZ4JEL3Q.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+import {
+  BytecutError,
+  CONFIG_FILES
+} from "./chunk-FY53B4NB.js";
+
+// src/core/fs-safe.ts
+import { randomBytes } from "crypto";
+import { lstat, mkdir, readFile, realpath, rename, unlink, writeFile } from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative, sep } from "path";
+function isInside(parent, child) {
+  const rel = relative(parent, child);
+  if (rel === "") return true;
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+async function realpathOfExisting(path) {
+  const rest = [];
+  let current = path;
+  for (; ; ) {
+    try {
+      return join(await realpath(current), ...rest.reverse());
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+      const parent = dirname(current);
+      if (parent === current) throw error;
+      rest.push(basename(current));
+      current = parent;
+    }
+  }
+}
+var SafeFs = class _SafeFs {
+  constructor(outDir) {
+    this.outDir = outDir;
+  }
+  outDir;
+  /** Validates `outDir` against §6.5 before anything can be written. */
+  static async create(options) {
+    const realOut = await realpathOfExisting(options.outDir);
+    const realRoot = await realpathOfExisting(options.projectRoot);
+    if (realOut === realRoot) {
+      throw new BytecutError(
+        "UNSAFE_OUT_DIR",
+        `Refusing to use the project root as the output folder (${options.outDir}).`
+      );
+    }
+    if (isInside(realOut, realRoot)) {
+      throw new BytecutError(
+        "UNSAFE_OUT_DIR",
+        `The output folder ${options.outDir} contains the project root.`
+      );
+    }
+    for (const dir of options.sourceDirs) {
+      const realDir = await realpathOfExisting(dir);
+      if (realOut === realDir) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} is itself a source folder.`
+        );
+      }
+      if (isInside(realOut, realDir)) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} contains the source folder ${dir}.`
+        );
+      }
+    }
+    for (const file of options.sourceFiles) {
+      if (isInside(realOut, await realpathOfExisting(file))) {
+        throw new BytecutError(
+          "UNSAFE_OUT_DIR",
+          `The output folder ${options.outDir} contains the source file ${file}.`
+        );
+      }
+    }
+    return new _SafeFs(realOut);
+  }
+  readSource(absolutePath) {
+    return readFile(absolutePath);
+  }
+  /** Validates a path relative to `outDir` and returns where it lives; touches nothing. */
+  locate(relativePosixPath) {
+    const segments = relativePosixPath.split("/");
+    if (isAbsolute(relativePosixPath) || relativePosixPath.includes("\\") || segments.some((s) => s === "" || s === "." || s === "..")) {
+      throw new BytecutError("UNSAFE_PATH", `Unsafe output path: ${relativePosixPath}`);
+    }
+    const target = join(this.outDir, ...segments);
+    return { target, dir: dirname(target) };
+  }
+  /**
+   * Reads a file we previously wrote (or one that sits where an output would go), or null if
+   * it doesn't exist. Same path checks as writes, and never reads through a symlink.
+   */
+  async readOutput(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to read through symlink: ${target}`);
+      }
+      return await readFile(target);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+  }
+  /** `relativePosixPath` is relative to `outDir`. */
+  async writeOutput(relativePosixPath, data) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    await mkdir(dir, { recursive: true });
+    await this.assertInside(await realpath(dir), relativePosixPath);
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${target}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const temp = join(dir, `.${basename(target)}.${randomBytes(6).toString("hex")}.tmp`);
+    try {
+      await writeFile(temp, data, { flag: "wx" });
+      await rename(temp, target);
+    } catch (error) {
+      await unlink(temp).catch(() => void 0);
+      throw error;
+    }
+  }
+  /**
+   * A path inside `outDir` for a child process (ffmpeg) to write to. The process writes it
+   * itself, so the write boundary is enforced here: the location is validated, never
+   * pre-existing, and only `commitTemp` can turn it into a real output (§6.4).
+   */
+  async reserveTemp(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    await mkdir(dir, { recursive: true });
+    await this.assertInside(await realpath(dir), relativePosixPath);
+    return join(dir, `.${basename(target)}.${randomBytes(6).toString("hex")}.tmp`);
+  }
+  /** Atomically publishes a file made through `reserveTemp` as `relativePosixPath`. */
+  async commitTemp(tempPath, relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    if (dirname(tempPath) !== dir || !basename(tempPath).endsWith(".tmp")) {
+      throw new BytecutError("UNSAFE_PATH", `Not a reserved temp file for ${relativePosixPath}`);
+    }
+    try {
+      if ((await lstat(target)).isSymbolicLink()) {
+        throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${target}`);
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await rename(tempPath, target);
+  }
+  /**
+   * Writes `data` to a reserved temp path and returns it, for handing a file to a child
+   * process (a native scorer). It is never an output: `discardTemp` removes it.
+   */
+  async writeTemp(relativePosixPath, data) {
+    const temp = await this.reserveTemp(relativePosixPath);
+    try {
+      await writeFile(temp, data, { flag: "wx" });
+    } catch (error) {
+      await unlink(temp).catch(() => void 0);
+      throw error;
+    }
+    return temp;
+  }
+  /** Removes a reserved temp file (after a failure or cancel). Never throws. */
+  async discardTemp(tempPath) {
+    if (!isInside(this.outDir, tempPath) || !basename(tempPath).endsWith(".tmp")) return;
+    await unlink(tempPath).catch(() => void 0);
+  }
+  /** Absolute path of an existing output, for reading it with a streaming API. */
+  async outputPath(relativePosixPath) {
+    const { target, dir } = this.locate(relativePosixPath);
+    await this.assertInside(await realpathOfExisting(dir), relativePosixPath);
+    return target;
+  }
+  async assertInside(resolved, requested) {
+    if (!isInside(this.outDir, resolved)) {
+      throw new BytecutError("UNSAFE_PATH", `Output path escapes the output folder: ${requested}`);
+    }
+  }
+};
+async function writeConfigFile(projectRoot, fileName, content) {
+  if (!CONFIG_FILES.includes(fileName)) {
+    throw new BytecutError("UNSAFE_PATH", `Not a bytecut config file name: ${fileName}`);
+  }
+  const target = join(await realpath(projectRoot), fileName);
+  try {
+    if ((await lstat(target)).isSymbolicLink()) {
+      throw new BytecutError("UNSAFE_PATH", `Refusing to write through symlink: ${fileName}`);
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const temp = join(dirname(target), `.${fileName}.${randomBytes(6).toString("hex")}.tmp`);
+  try {
+    await writeFile(temp, content, { flag: "wx" });
+    await rename(temp, target);
+  } catch (error) {
+    await unlink(temp).catch(() => void 0);
+    throw error;
+  }
+  return target;
+}
+
+export {
+  SafeFs,
+  writeConfigFile
+};

package/dist/chunk-KN5QOB7R.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+import {
+  isFile,
+  readOsReleaseId,
+  run
+} from "./chunk-S3FQYUTI.js";
+import {
+  createFfmpegVideoEngine
+} from "./chunk-QOG2F4SF.js";
+import {
+  installHint,
+  resolveBinary,
+  resolveConfig
+} from "./chunk-3PF6BBFK.js";
+import {
+  BytecutError,
+  loadConfig
+} from "./chunk-FY53B4NB.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-LTWUPQDT.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+
+// src/core/engines/svg.ts
+import { VERSION, optimize } from "svgo";
+var EMBEDDED_RASTER = /data:image\/(?:png|jpe?g|webp|gif|avif)[^"')\s]*?;base64,([A-Za-z0-9+/=\s]+)/gi;
+var svgoEngine = {
+  version: () => `svgo ${VERSION}`,
+  analyze(text) {
+    let embeddedRasterBytes = 0;
+    let embeddedRasterCount = 0;
+    for (const match of text.matchAll(EMBEDDED_RASTER)) {
+      embeddedRasterCount++;
+      embeddedRasterBytes += match[1].replace(/\s/g, "").length;
+    }
+    let minifiedBytes = null;
+    try {
+      minifiedBytes = Buffer.byteLength(optimize(text, { multipass: true }).data);
+    } catch {
+    }
+    return { minifiedBytes, embeddedRasterBytes, embeddedRasterCount };
+  }
+};
+
+export {
+  svgoEngine
+};

package/dist/chunk-MV6J66AP.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import {
+  BytecutError
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/errors.ts
+function guarded(run) {
+  return async (context) => {
+    try {
+      await run(context);
+    } catch (error) {
+      if (!(error instanceof BytecutError)) throw error;
+      console.error(`bytecut: ${error.message} [${error.code}]`);
+      process.exitCode = 1;
+    }
+  };
+}
+
+export {
+  guarded
+};