bytecut 0.0.0-stage → 0.1.0

package/dist/chunk-TCQFQ354.js

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+import {
+  BytecutError
+} from "./chunk-FY53B4NB.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(["jpg", "png", "webp", "avif"]),
+  width: z.number().int().positive(),
+  lossless: z.boolean(),
+  quality: z.number().int().min(1).max(100),
+  effort: z.number().int().min(0).max(10),
+  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(["jpg", "png", "webp", "avif"]),
+  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
+};

package/dist/chunk-WZ6MMRNB.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+import {
+  fallbackAv1CodecString
+} from "./chunk-3DBJKHOD.js";
+
+// src/core/snippets/render.ts
+var JSX_NAMES = {
+  class: "className",
+  srcset: "srcSet",
+  fetchpriority: "fetchPriority",
+  playsinline: "playsInline",
+  autoplay: "autoPlay",
+  crossorigin: "crossOrigin",
+  decoding: "decoding",
+  tabindex: "tabIndex"
+};
+var kebab = (s) => s.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+var camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+function escapeHtml(value, quote) {
+  let out = value.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+  out = quote === '"' ? out.replace(/"/g, "&quot;") : out.replace(/'/g, "&#39;");
+  return out;
+}
+function htmlValue(value) {
+  if (value.includes('"') && !value.includes("'")) return `'${escapeHtml(value, "'")}'`;
+  return `"${escapeHtml(value, '"')}"`;
+}
+function jsxValue(value) {
+  const plain = /^[\x20-\x7e]*$/.test(value) && !/[\\{}&<>]/.test(value);
+  if (plain && !value.includes('"')) return `"${value}"`;
+  if (plain && !value.includes("'")) return `'${value}'`;
+  return `{${JSON.stringify(value)}}`;
+}
+function renderAttr(attr, syntax) {
+  if (syntax === "html") {
+    if (attr.value === true) return attr.name;
+    if (typeof attr.value === "string") return `${attr.name}=${htmlValue(attr.value)}`;
+    const css = Object.entries(attr.value.style).map(([k, v]) => `${kebab(k)}:${v}`).join(";");
+    return `style=${htmlValue(css)}`;
+  }
+  const name = JSX_NAMES[attr.name] ?? attr.name;
+  if (attr.value === true) return name;
+  if (typeof attr.value === "string") return `${name}=${jsxValue(attr.value)}`;
+  const body = Object.entries(attr.value.style).map(([k, v]) => `${camel(k)}: ${JSON.stringify(v)}`).join(", ");
+  return `style={{ ${body} }}`;
+}
+var VOID = /* @__PURE__ */ new Set(["source", "img"]);
+function render(el, syntax, indent = "") {
+  const attrs = el.attrs.map((a) => renderAttr(a, syntax));
+  const open = [el.tag, ...attrs].join(" ");
+  if (VOID.has(el.tag)) return `${indent}<${open}${syntax === "jsx" ? " /" : ""}>`;
+  const children = el.children ?? [];
+  if (children.length === 0) return `${indent}<${open}></${el.tag}>`;
+  const inner = children.map((c) => render(c, syntax, `${indent}  `)).join("\n");
+  return `${indent}<${open}>
+${inner}
+${indent}</${el.tag}>`;
+}
+
+// src/core/snippets/build.ts
+function encodeUrl(url) {
+  return url.split("/").map((segment) => segment === "" ? segment : encodeURIComponent(decodeSafe(segment))).join("/");
+}
+function decodeSafe(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+var MIME = { avif: "image/avif", webp: "image/webp" };
+var byWidth = (a, b) => a.width - b.width;
+function placeholderAttrs(p) {
+  if (!p) return [];
+  switch (p.kind) {
+    case "dominant-color":
+      return [{ name: "style", value: { style: { backgroundColor: p.value } } }];
+    case "lqip":
+      return [
+        {
+          name: "style",
+          value: {
+            style: {
+              backgroundImage: `url(${p.value})`,
+              backgroundSize: "cover"
+            }
+          }
+        }
+      ];
+    case "blurhash":
+      return [{ name: "data-blurhash", value: p.value }];
+  }
+}
+function imageElement(entry, target, options) {
+  const hints = [];
+  const written = entry.outputs.filter((o) => o.status === "written");
+  const ofFormat = (f) => written.filter((o) => o.format === f).sort(byWidth);
+  const sources = [];
+  for (const format of ["avif", "webp"]) {
+    const outs = ofFormat(format);
+    if (outs.length === 0) continue;
+    sources.push({
+      tag: "source",
+      attrs: [
+        { name: "type", value: MIME[format] },
+        {
+          name: "srcset",
+          value: outs.map((o) => `${encodeUrl(o.url)} ${o.width}w`).join(", ")
+        },
+        { name: "sizes", value: options.sizes ?? "100vw" }
+      ]
+    });
+  }
+  const compatible = ofFormat("jpg").length > 0 ? ofFormat("jpg") : ofFormat("png");
+  const fallbackSet = compatible.length > 0 ? compatible : ofFormat("webp");
+  const fallback = fallbackSet[fallbackSet.length - 1];
+  if (!fallback) {
+    hints.push(
+      sources.length === 0 ? "No optimized outputs were written (they were not smaller than the source), so this uses the original file." : "No JPEG, PNG or WebP output exists, so the <img> falls back to the original file."
+    );
+  }
+  const priority = options.priority ?? entry.priority === true;
+  const lazy = options.lazy ?? !priority;
+  const src = fallback ? encodeUrl(fallback.url) : encodeUrl(target.originalUrl);
+  const width = fallback?.width ?? entry.width;
+  const height = fallback?.height ?? entry.height;
+  const img = [
+    { name: "src", value: src },
+    // Several JPEG/PNG widths and no <picture> to carry them: the <img> carries the set.
+    ...compatible.length > 1 ? [
+      {
+        name: "srcset",
+        value: compatible.map((o) => `${encodeUrl(o.url)} ${o.width}w`).join(", ")
+      },
+      { name: "sizes", value: options.sizes ?? "100vw" }
+    ] : [],
+    { name: "width", value: String(width) },
+    { name: "height", value: String(height) },
+    { name: "alt", value: options.alt ?? "" }
+  ];
+  if (options.className) img.push({ name: "class", value: options.className });
+  if (priority) img.push({ name: "fetchpriority", value: "high" });
+  if (lazy) img.push({ name: "loading", value: "lazy" });
+  img.push({ name: "decoding", value: "async" });
+  img.push(...placeholderAttrs(entry.placeholder));
+  if (options.alt === void 0) {
+    hints.push(
+      'alt text is empty (marks the image decorative). Set it with --alt "\u2026" if it carries meaning.'
+    );
+  }
+  const imgEl = { tag: "img", attrs: img };
+  const el = sources.length === 0 ? imgEl : { tag: "picture", attrs: [], children: [...sources, imgEl] };
+  return { el, hints };
+}
+var LOOPING = /* @__PURE__ */ new Set(["background-video", "gif-to-video"]);
+function videoType(out) {
+  if (out.codecs) return `video/mp4; codecs="${out.codecs}"`;
+  if (out.codec === "av1")
+    return `video/mp4; codecs="${fallbackAv1CodecString(out.width, out.height)}"`;
+  return "video/mp4";
+}
+function videoElement(entry, _target, options) {
+  const hints = [];
+  const videos = entry.outputs.filter((o) => o.role === "video" && o.status === "written");
+  const order = { av1: 0, h264: 1 };
+  videos.sort((a, b) => (order[a.codec ?? "h264"] ?? 9) - (order[b.codec ?? "h264"] ?? 9));
+  const poster = entry.outputs.find((o) => o.role === "poster" && o.status === "written");
+  if (videos.length === 0) {
+    hints.push("No video outputs were written, so there is nothing to embed.");
+  }
+  const main = videos[0];
+  const looping = LOOPING.has(entry.preset);
+  const controls = options.controls ?? !looping;
+  const attrs = [];
+  if (main) {
+    attrs.push({ name: "width", value: String(main.width) });
+    attrs.push({ name: "height", value: String(main.height) });
+  }
+  if (options.className) attrs.push({ name: "class", value: options.className });
+  if (poster) attrs.push({ name: "poster", value: encodeUrl(poster.url) });
+  if (looping) {
+    attrs.push(
+      { name: "autoplay", value: true },
+      { name: "muted", value: true },
+      { name: "loop", value: true },
+      { name: "playsinline", value: true }
+    );
+  } else {
+    attrs.push({ name: "playsinline", value: true });
+  }
+  if (controls) attrs.push({ name: "controls", value: true });
+  attrs.push({ name: "preload", value: looping ? "auto" : "metadata" });
+  attrs.push(...placeholderAttrs(entry.placeholder));
+  const children = videos.map((o) => ({
+    tag: "source",
+    attrs: [
+      { name: "src", value: encodeUrl(o.url) },
+      { name: "type", value: videoType(o) }
+    ]
+  }));
+  return { el: { tag: "video", attrs, children }, hints };
+}
+function lookup(manifest, source) {
+  const image = manifest.sources[source];
+  if (image) return { kind: "image", entry: image };
+  const video = manifest.videos[source];
+  if (video) return { kind: "video", entry: video };
+  return null;
+}
+function buildSnippet(manifest, target, options) {
+  const found = lookup(manifest, target.source);
+  if (!found) return null;
+  const { el, hints } = found.kind === "image" ? imageElement(found.entry, target, options) : videoElement(found.entry, target, options);
+  return { kind: found.kind, source: target.source, code: render(el, options.format), hints };
+}
+
+// src/core/snippets/format.ts
+function originalUrl(source, staticRoot) {
+  const rel = staticRoot === "." || staticRoot === "" ? source : source.startsWith(`${staticRoot}/`) ? source.slice(staticRoot.length + 1) : source;
+  return `/${rel}`;
+}
+function snippetFormatFor(project) {
+  switch (project.framework) {
+    case "next":
+      return "jsx";
+    case "vite":
+      return project.react ? "jsx" : "html";
+    case "astro":
+    case "static":
+      return "html";
+  }
+}
+
+export {
+  buildSnippet,
+  originalUrl,
+  snippetFormatFor
+};