bytecut 0.0.0-stage → 0.1.0

package/dist/explain-TS6XF5TX.js

@@ -0,0 +1,267 @@
+#!/usr/bin/env node
+import {
+  sharpImageEngine
+} from "./chunk-CSFBJ3UH.js";
+import {
+  classify,
+  classifyVideo,
+  mirroredDir,
+  outputWidths,
+  plannedVideoOutputs
+} from "./chunk-XUBQWBWH.js";
+import {
+  configArg,
+  createVideoEngine,
+  discover
+} from "./chunk-KN5QOB7R.js";
+import "./chunk-S3FQYUTI.js";
+import {
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import {
+  getVideoPreset
+} from "./chunk-3PF6BBFK.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError,
+  formatBytes,
+  matchesGlob
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/explain.ts
+import { stat } from "fs/promises";
+import { resolve as resolve2 } from "path";
+import { defineCommand } from "citty";
+
+// src/core/config/explain.ts
+import { readFile } from "fs/promises";
+import { extname, posix, relative, resolve } from "path";
+var RASTER = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png", ".webp", ".avif", ".gif"]);
+var VIDEO = /* @__PURE__ */ new Set([".mp4", ".webm", ".mov", ".m4v", ".mkv"]);
+async function explainFile(options) {
+  const { config, projectRoot } = options;
+  const absolute = resolve(projectRoot, options.file);
+  const source = toPosix(relative(projectRoot, absolute));
+  const ext = extname(source).toLowerCase();
+  const { catalog } = config;
+  const base = {
+    source,
+    outDir: config.project.outDir,
+    publicPath: config.project.publicPath,
+    excluded: false,
+    auditIgnored: config.auditIgnore.some((p) => matchesGlob(p, source))
+  };
+  const none = (kind, reason) => ({
+    ...base,
+    kind,
+    decision: { by: "unavailable", reason },
+    preset: null,
+    chain: [],
+    changedBy: [],
+    resolved: null,
+    outputs: []
+  });
+  if (ext === ".svg") return none("svg", "SVG output is not implemented yet");
+  const isVideo = VIDEO.has(ext);
+  if (!isVideo && !RASTER.has(ext))
+    return none("unsupported", `${ext || "this"} is not a supported type`);
+  const matched = config.policy.assetFor(source);
+  const detail = (preset2) => ({
+    chain: catalog.origin[preset2]?.chain ?? [preset2],
+    changedBy: catalog.origin[preset2]?.overrides ?? []
+  });
+  const pick = (kind, classifier) => {
+    const known = (name) => kind === "image" ? catalog.image[name] : catalog.video[name];
+    if (options.presetFlag) {
+      if (!known(options.presetFlag)) {
+        return {
+          preset: null,
+          decision: {
+            by: "unavailable",
+            reason: `--preset ${options.presetFlag} is not a ${kind} preset`
+          }
+        };
+      }
+      return {
+        preset: options.presetFlag,
+        decision: { by: "flag", reason: `forced with --preset ${options.presetFlag}` }
+      };
+    }
+    if (matched && known(matched.preset)) {
+      return {
+        preset: matched.preset,
+        decision: {
+          by: "assets",
+          pattern: matched.pattern,
+          reason: `matched assets "${matched.pattern}"`
+        }
+      };
+    }
+    const verdict = classifier();
+    if (!verdict) {
+      return {
+        preset: null,
+        decision: {
+          by: "unavailable",
+          reason: "classifying a video needs ffprobe, which was not found"
+        }
+      };
+    }
+    return {
+      preset: verdict.preset,
+      decision: { by: "classifier", reason: verdict.reason, confidence: verdict.confidence }
+    };
+  };
+  if (!isVideo) {
+    const data = await readFile(absolute);
+    const analysis = await options.engine.analyze(data);
+    if (!(analysis.animated && analysis.format === "gif")) {
+      const { preset: preset2, decision: decision2 } = pick("image", () => classify(source, analysis));
+      const resolved2 = preset2 ? catalog.image[preset2] : null;
+      const dir = mirroredDir(source, config.project.staticRoot);
+      const name = posix.basename(source, posix.extname(source));
+      const outputs = resolved2 ? outputWidths(resolved2, analysis.width, analysis.height).flatMap(
+        (w) => resolved2.formats.map((f) => posix.join(dir, name, `${name}-${w}.${f}`))
+      ) : [];
+      return {
+        ...base,
+        kind: "image",
+        decision: decision2,
+        preset: preset2,
+        ...preset2 ? detail(preset2) : { chain: [], changedBy: [] },
+        resolved: resolved2,
+        outputs
+      };
+    }
+  }
+  const probe = options.videoEngine ? await options.videoEngine.probe(absolute).catch(() => null) : null;
+  const isGif = ext === ".gif";
+  const { preset, decision } = pick("video", () => {
+    if (isGif) return { preset: "gif-to-video", reason: "animated GIF", confidence: "high" };
+    return probe ? classifyVideo(source, probe) : null;
+  });
+  const resolved = preset ? getVideoPreset(preset, catalog) ?? null : null;
+  return {
+    ...base,
+    kind: "video",
+    decision,
+    preset,
+    ...preset ? detail(preset) : { chain: [], changedBy: [] },
+    resolved,
+    outputs: resolved && probe ? plannedVideoOutputs(source, config.project.staticRoot, resolved, probe).map((o) => o.path) : []
+  };
+}
+function formatExplanation(e) {
+  const lines = [e.source];
+  lines.push(`  type:     ${e.kind}`);
+  if (e.preset === null) {
+    lines.push(`  preset:   none (${e.decision.reason})`);
+  } else {
+    const how = e.decision.by === "assets" ? `assets rule "${e.decision.pattern}"` : e.decision.by === "flag" ? "the --preset flag" : e.decision.by === "classifier" ? `classifier, ${e.decision.confidence} confidence: ${e.decision.reason}` : e.decision.reason;
+    lines.push(`  preset:   ${e.preset}  (from ${how})`);
+    if (e.chain.length > 1 || e.changedBy.length > 0) {
+      lines.push(`  extends:  ${e.chain.join(" \u2192 ")}`);
+      if (e.changedBy.length > 0) lines.push(`  changed:  ${e.changedBy.join(", ")}`);
+    }
+  }
+  const r = e.resolved;
+  if (r && "widths" in r) {
+    lines.push(
+      r.maxEdge !== void 0 ? `  size:     longest side up to ${r.maxEdge}px (width if landscape, height if portrait; never above the source)` : `  widths:   ${r.widths.join(", ")} (never above the source)`
+    );
+    lines.push(`  formats:  ${r.formats.join(", ")}`);
+    for (const f of r.formats) {
+      const lossless = r.lossless ? ", lossless" : "";
+      lines.push(
+        `  ${f}:     quality ${r.encoders[f].quality}, effort ${r.encoders[f].effort}${lossless}`
+      );
+    }
+    lines.push(`  priority: ${r.priority ? "yes (fetchpriority=high, never lazy)" : "no"}`);
+    if (r.search) {
+      const parts = [`ssimulacra2 >= ${r.search.target}`];
+      if (r.search.maxBytes !== void 0) {
+        parts.push(
+          `at most ${formatBytes(r.search.maxBytes)} per file, quality may fall to a score of ${r.search.floor}`
+        );
+      }
+      lines.push(
+        `  search:   ${parts.join("; ")} (quality is found per image; lossless outputs are exact)`
+      );
+    }
+  } else if (r) {
+    lines.push(`  codecs:   ${r.codecs.join(", ")}`);
+    lines.push(`  audio:    ${r.audio === "strip" ? "removed" : "kept"}`);
+    lines.push(
+      `  cap:      ${r.maxWidth ? `${r.maxWidth}px wide` : "no width cap"}, ${r.maxFps ? `${r.maxFps} fps` : "no fps cap"}`
+    );
+    lines.push(`  crf:      av1 ${r.crf.av1}, h264 ${r.crf.h264}`);
+    if (r.search) {
+      lines.push(
+        `  search:   ${r.search.metric} >= ${r.search.target} on the worst of 3 sampled clips (crf above is the starting point)`
+      );
+    }
+  }
+  if (e.outputs.length > 0) {
+    lines.push(`  outputs:  ${e.outDir}/`);
+    for (const o of e.outputs) lines.push(`    ${o}`);
+  }
+  if (e.auditIgnored)
+    lines.push("  note:     matched audit.ignore, so audit raises no findings for it");
+  return lines.join("\n");
+}
+
+// src/cli/commands/explain.ts
+var explain_default = defineCommand({
+  meta: {
+    name: "explain",
+    description: "Show which rule chose a file's preset and what that preset resolves to"
+  },
+  args: {
+    ...configArg,
+    preset: { type: "string", description: "Show the result of forcing this preset" },
+    json: { type: "boolean", description: "Print the explanation as JSON" },
+    ffmpeg: { type: "string", description: "Path to the ffmpeg binary" },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" }
+  },
+  run: guarded(async ({ args }) => {
+    const files = args._.map(String);
+    if (files.length === 0) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "Name a file, e.g. `bytecut explain public/img/hero.jpg`."
+      );
+    }
+    const found = await discover([], void 0, args.config);
+    const engine = createVideoEngine({ ffmpeg: args.ffmpeg, ffprobe: args.ffprobe }, found.config);
+    const results = [];
+    for (const file of files) {
+      if (!(await stat(resolve2(found.projectRoot, file)).catch(() => null))?.isFile()) {
+        throw new BytecutError("INPUT_NOT_FOUND", `No such file: ${file}`);
+      }
+      results.push(
+        await explainFile({
+          projectRoot: found.projectRoot,
+          file,
+          config: found.config,
+          engine: sharpImageEngine,
+          videoEngine: engine,
+          presetFlag: args.preset
+        })
+      );
+    }
+    if (args.json) {
+      process.stdout.write(`${JSON.stringify({ version: 1, files: results }, null, 2)}
+`);
+      return;
+    }
+    const where = found.config.loaded ? found.config.loaded.name : "no config (zero-config)";
+    console.log(`Config: ${where}
+`);
+    console.log(results.map(formatExplanation).join("\n\n"));
+  })
+});
+export {
+  explain_default as default
+};

package/dist/init-CWDWVJ55.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import {
+  isGitIgnored
+} from "./chunk-DJ45NQZD.js";
+import {
+  applyChoices,
+  isEmpty,
+  renderConfig
+} from "./chunk-4FIB6VNC.js";
+import {
+  writeConfigFile
+} from "./chunk-IZ4JEL3Q.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError,
+  FRAMEWORKS,
+  PLACEHOLDERS,
+  detectProject,
+  findConfigFiles
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/init.ts
+import { relative } from "path";
+import { defineCommand } from "citty";
+import { resolve } from "path";
+var FILE = "bytecut.config.json";
+var init_default = defineCommand({
+  meta: {
+    name: "init",
+    description: "Write a minimal bytecut.config.json containing only non-default choices"
+  },
+  args: {
+    "out-dir": { type: "string", description: "Output folder to record" },
+    "public-path": { type: "string", description: "URL prefix to record" },
+    framework: { type: "string", description: `Framework to record (${FRAMEWORKS.join(", ")})` },
+    placeholder: {
+      type: "string",
+      description: `Placeholder to record (${PLACEHOLDERS.join(", ")})`
+    }
+  },
+  run: guarded(async ({ args }) => {
+    const projectRoot = process.cwd();
+    const existing = await findConfigFiles(projectRoot);
+    if (existing.length > 0) {
+      throw new BytecutError(
+        "CONFIG_EXISTS",
+        `${existing[0]} already exists; edit it instead. init never overwrites a config.`
+      );
+    }
+    const framework = args.framework;
+    if (framework !== void 0 && !FRAMEWORKS.includes(framework)) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        `--framework must be one of ${FRAMEWORKS.join(", ")}.`
+      );
+    }
+    const placeholder = args.placeholder;
+    if (placeholder !== void 0 && !PLACEHOLDERS.includes(placeholder)) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        `--placeholder must be one of ${PLACEHOLDERS.join(", ")}.`
+      );
+    }
+    const detected = await detectProject(projectRoot);
+    const effective = await detectProject(projectRoot, { framework });
+    const choices = {
+      ...args["out-dir"] && args["out-dir"] !== effective.outDir ? { outDir: args["out-dir"] } : {},
+      ...args["public-path"] && args["public-path"] !== effective.publicPath ? { publicPath: args["public-path"] } : {},
+      ...placeholder && placeholder !== "dominant-color" ? { placeholder } : {}
+    };
+    const data = applyChoices(
+      framework && framework !== detected.framework ? { framework } : {},
+      choices
+    );
+    const path = await writeConfigFile(projectRoot, FILE, renderConfig("json", data));
+    console.log(
+      isEmpty(choices) && !data.framework ? `Wrote ${relative(projectRoot, path)} with no overrides: everything is at its default.` : `Wrote ${relative(projectRoot, path)}:
+${renderConfig("json", data)}`
+    );
+    const outDir = args["out-dir"] ?? effective.outDir;
+    if (await isGitIgnored(projectRoot, resolve(projectRoot, outDir))) {
+      console.warn(
+        `Note: ${outDir} is matched by a .gitignore. bytecut's outputs are meant to be committed so deploys need no encoding step. Nothing was changed.`
+      );
+    }
+  })
+});
+export {
+  init_default as default
+};

package/dist/optimize-47YALM3D.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+import {
+  package_default
+} from "./chunk-AYYKUSRP.js";
+import {
+  formatFindings,
+  formatPlan,
+  formatSummary,
+  optimize
+} from "./chunk-P5PFI3AO.js";
+import "./chunk-3DBJKHOD.js";
+import {
+  isPlaceholderKind,
+  parsePlan,
+  serializePlan
+} from "./chunk-TCQFQ354.js";
+import {
+  sharpImageEngine
+} from "./chunk-CSFBJ3UH.js";
+import "./chunk-XUBQWBWH.js";
+import {
+  configArg,
+  createVideoEngine,
+  ffmpegInstallText,
+  makeScorerFactory
+} from "./chunk-KN5QOB7R.js";
+import "./chunk-S3FQYUTI.js";
+import "./chunk-QOG2F4SF.js";
+import {
+  resolveConfig
+} from "./chunk-3PF6BBFK.js";
+import "./chunk-IZ4JEL3Q.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError,
+  loadConfig
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/optimize.ts
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { availableParallelism } from "os";
+import { resolve } from "path";
+import { defineCommand } from "citty";
+var FRAMEWORK_NAMES = {
+  next: "Next.js",
+  astro: "Astro",
+  vite: "Vite",
+  static: "a static site"
+};
+var plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+var optimize_default = defineCommand({
+  meta: {
+    name: "optimize",
+    description: "Optimize images into the output folder (sources are never modified)"
+  },
+  args: {
+    ...configArg,
+    yes: {
+      type: "boolean",
+      alias: "y",
+      description: "Write outputs; without it only the plan is printed"
+    },
+    "dry-run": { type: "boolean", description: "Print the plan and write nothing" },
+    json: { type: "boolean", description: "With --dry-run: print the plan as JSON on stdout" },
+    plan: { type: "string", description: "Execute a plan saved with --dry-run --json" },
+    force: {
+      type: "boolean",
+      description: "Re-encode unchanged files and overwrite outputs bytecut does not own"
+    },
+    "out-dir": {
+      type: "string",
+      description: "Output folder (default: from the detected framework)"
+    },
+    "public-path": { type: "string", description: "URL prefix for outputs (default: /_bytecut)" },
+    preset: {
+      type: "string",
+      description: "Force a preset (images: photo, hero, icon; video: background-video, content-video, gif-to-video)"
+    },
+    placeholder: {
+      type: "string",
+      description: "Placeholder to record in the manifest: dominant-color (default), lqip, blurhash or none"
+    },
+    ffmpeg: {
+      type: "string",
+      description: "Path to the ffmpeg binary (otherwise BYTECUT_FFMPEG, then PATH)"
+    },
+    ffprobe: { type: "string", description: "Path to the ffprobe binary" },
+    ssimulacra2: {
+      type: "string",
+      description: "Path to a native ssimulacra2 for quality searches (otherwise BYTECUT_SSIMULACRA2, then PATH, then the built-in scorer)"
+    }
+  },
+  run: guarded(async ({ args }) => {
+    const inputs = args._.map(String);
+    const planFile = args.plan;
+    const dryRun = Boolean(args["dry-run"]) || !args.yes;
+    if (planFile && (inputs.length > 0 || args["out-dir"] || args["public-path"])) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "--plan already fixes the sources, output folder and public path; don't combine it with paths, --out-dir or --public-path."
+      );
+    }
+    if (planFile && args.preset) {
+      throw new BytecutError("BAD_ARGUMENTS", "--plan already fixes each file's preset.");
+    }
+    if (args.json && !dryRun) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "--json is only supported with --dry-run for now (stdout would mix two formats)."
+      );
+    }
+    let savedPlan;
+    if (planFile) {
+      const text = await readFile(resolve(planFile), "utf8").catch(() => {
+        throw new BytecutError("INPUT_NOT_FOUND", `Cannot read plan file: ${planFile}`);
+      });
+      savedPlan = parsePlan(text, planFile);
+    }
+    let placeholder;
+    if (args.placeholder !== void 0) {
+      const wanted = String(args.placeholder);
+      if (wanted !== "none" && !isPlaceholderKind(wanted)) {
+        throw new BytecutError(
+          "BAD_ARGUMENTS",
+          `Unknown placeholder "${wanted}". Use dominant-color, lqip, blurhash or none.`
+        );
+      }
+      placeholder = wanted;
+    }
+    const controller = new AbortController();
+    const onSigint = () => controller.abort();
+    if (!dryRun) process.once("SIGINT", onSigint);
+    const projectRoot = process.cwd();
+    const config = await resolveConfig(projectRoot, await loadConfig(projectRoot, args.config));
+    const project = config.project;
+    placeholder ??= config.placeholder;
+    let scanInputs = inputs;
+    if (!savedPlan && inputs.length === 0) {
+      scanInputs = project.include.filter((p) => existsSync(resolve(projectRoot, p)));
+      if (scanInputs.length === 0) {
+        console.error(
+          `bytecut optimize: no asset folder found (looked for ${project.include.join(", ")}). Pass files or folders.`
+        );
+        process.exitCode = 2;
+        return;
+      }
+      console.error(
+        `Detected ${FRAMEWORK_NAMES[project.framework]}: scanning ${scanInputs.join(", ")} \u2192 ${args["out-dir"] ?? project.outDir}`
+      );
+    }
+    const outcome = await optimize({
+      projectRoot,
+      engine: sharpImageEngine,
+      toolVersion: package_default.version,
+      ...savedPlan ? { savedPlan } : { inputs: scanInputs },
+      outDir: savedPlan?.outDir ?? args["out-dir"] ?? project.outDir,
+      staticRoot: project.staticRoot,
+      publicPath: args["public-path"] ?? project.publicPath,
+      policy: config.policy,
+      exclude: config.exclude,
+      makeScorer: makeScorerFactory(args.ssimulacra2, config),
+      ...args.preset ? { presetOverride: args.preset } : {},
+      ...placeholder ? { placeholder } : {},
+      execute: !dryRun,
+      force: Boolean(args.force),
+      concurrency: config.concurrency ?? Math.min(4, availableParallelism()),
+      videoEngine: createVideoEngine({ ffmpeg: args.ffmpeg, ffprobe: args.ffprobe }, config),
+      needsFfmpeg: ffmpegInstallText(),
+      signal: controller.signal,
+      onItemDone: (item, done, total) => console.error(`[${done}/${total}] ${item.source}`),
+      onVideoItemDone: (item, done, total) => console.error(`[video ${done}/${total}] ${item.source}`)
+    });
+    process.off("SIGINT", onSigint);
+    for (const file of outcome.unsupported) {
+      console.warn(`Skipping ${file}: not a supported image (JPEG, PNG, WebP, AVIF).`);
+    }
+    if (outcome.svgs.length > 0) {
+      console.warn(
+        `Skipping ${plural(outcome.svgs.length, "SVG file")}: SVG output is not implemented yet (see \`bytecut audit\`).`
+      );
+    }
+    if (outcome.plan.items.length === 0 && (outcome.plan.videos ?? []).length === 0) {
+      console.log("No images or videos found.");
+      return;
+    }
+    const findings = formatFindings(outcome.findings);
+    for (const note of outcome.notes) console.error(`Note: ${note}`);
+    if (dryRun) {
+      if (args.json) {
+        process.stdout.write(serializePlan(outcome.plan));
+        if (findings) console.error(findings);
+        return;
+      }
+      console.log(formatPlan(outcome.plan, outcome.cache));
+      if (findings) console.log(`
+${findings}`);
+      console.log("\nDry run: nothing written. Re-run with -y to write these outputs.");
+      return;
+    }
+    const result = outcome.result;
+    console.log(formatSummary(result));
+    for (const warning of result.warnings) console.warn(`warning: ${warning}`);
+    if (findings) console.log(`
+${findings}`);
+    if (result.cancelled) process.exitCode = 130;
+    else if (result.items.some((i) => i.status === "failed") || (result.videos ?? []).some((v) => v.status === "failed")) {
+      process.exitCode = 1;
+    }
+  })
+});
+export {
+  optimize_default as default
+};

package/dist/snippet-IIPVF6PS.js

@@ -0,0 +1,114 @@
+#!/usr/bin/env node
+import {
+  buildSnippet,
+  originalUrl,
+  snippetFormatFor
+} from "./chunk-WZ6MMRNB.js";
+import "./chunk-3DBJKHOD.js";
+import {
+  MANIFEST_FILE,
+  parseManifest
+} from "./chunk-TCQFQ354.js";
+import {
+  configArg,
+  discover
+} from "./chunk-KN5QOB7R.js";
+import "./chunk-S3FQYUTI.js";
+import {
+  toPosix
+} from "./chunk-QOG2F4SF.js";
+import "./chunk-3PF6BBFK.js";
+import {
+  guarded
+} from "./chunk-MV6J66AP.js";
+import {
+  BytecutError
+} from "./chunk-FY53B4NB.js";
+
+// src/cli/commands/snippet.ts
+import { readFile } from "fs/promises";
+import { relative, resolve } from "path";
+import { defineCommand } from "citty";
+var snippet_default = defineCommand({
+  meta: {
+    name: "snippet",
+    description: "Print the <picture> / <video> markup for files that have been optimized"
+  },
+  args: {
+    ...configArg,
+    format: { type: "string", description: "html or jsx (default: from the detected framework)" },
+    alt: { type: "string", description: "Alt text for images (default: empty, i.e. decorative)" },
+    sizes: { type: "string", description: 'The sizes attribute (default: "100vw")' },
+    class: { type: "string", description: "A class (className in JSX) to add to the element" },
+    priority: {
+      type: "boolean",
+      description: 'Mark as the main image: fetchpriority="high", no lazy loading'
+    },
+    lazy: { type: "boolean", description: "Lazy-load even a priority image" },
+    "out-dir": { type: "string", description: "Output folder (default: from the framework)" },
+    json: { type: "boolean", description: "Print structured data instead of markup" }
+  },
+  run: guarded(async ({ args }) => {
+    const inputs = args._.map(String);
+    if (inputs.length === 0) {
+      throw new BytecutError(
+        "BAD_ARGUMENTS",
+        "Name at least one optimized file, e.g. `bytecut snippet public/img/hero.jpg`."
+      );
+    }
+    const found = await discover([], args["out-dir"], args.config);
+    const format = args.format ?? snippetFormatFor(found.project);
+    if (format !== "html" && format !== "jsx") {
+      throw new BytecutError("BAD_ARGUMENTS", `--format must be html or jsx, not "${format}".`);
+    }
+    let manifestText;
+    try {
+      manifestText = await readFile(
+        resolve(found.projectRoot, found.outDir, MANIFEST_FILE),
+        "utf8"
+      );
+    } catch {
+      throw new BytecutError(
+        "INPUT_NOT_FOUND",
+        `No manifest at ${found.outDir}/${MANIFEST_FILE}. Run \`bytecut optimize -y\` first.`
+      );
+    }
+    const manifest = parseManifest(manifestText);
+    const results = [];
+    for (const input of inputs) {
+      const source = toPosix(relative(found.projectRoot, resolve(found.projectRoot, input)));
+      const snippet = buildSnippet(
+        manifest,
+        { source, originalUrl: originalUrl(source, found.project.staticRoot) },
+        {
+          format,
+          ...args.alt !== void 0 ? { alt: String(args.alt) } : {},
+          ...args.sizes ? { sizes: String(args.sizes) } : {},
+          ...args.class ? { className: String(args.class) } : {},
+          ...args.priority ? { priority: true } : {},
+          ...args.lazy ? { lazy: true } : {}
+        }
+      );
+      if (!snippet) {
+        throw new BytecutError(
+          "INPUT_NOT_FOUND",
+          `${source} has not been optimized yet. Run \`bytecut optimize -y ${input}\` first.`
+        );
+      }
+      results.push(snippet);
+    }
+    if (args.json) {
+      process.stdout.write(
+        `${JSON.stringify({ version: 1, format, snippets: results }, null, 2)}
+`
+      );
+      return;
+    }
+    console.log(results.map((s) => s.code).join("\n\n"));
+    for (const s of results)
+      for (const hint of s.hints) console.error(`Note (${s.source}): ${hint}`);
+  })
+});
+export {
+  snippet_default as default
+};