@higgsfield/video-editor-mcp 1.0.7 → 1.1.1-dev.0

package/node_modules/@higgsfield/higgsedit/dist/chunk-YLVXQIPX.mjs

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+import { createRequire as __higgseditRequire } from "node:module";
+import { fileURLToPath as __higgseditPath } from "node:url";
+const require = __higgseditRequire(import.meta.url);
+const __filename = __higgseditPath(import.meta.url);
+const __dirname = __filename.slice(0, __filename.lastIndexOf("/"));
+import {
+  SourceProject,
+  applyEdit,
+  isLiteral,
+  literalValue,
+  require_ts_morph
+} from "./chunk-MV2JTTBQ.mjs";
+import {
+  findTool,
+  requireTool
+} from "./chunk-PAHMD6SU.mjs";
+import {
+  flag
+} from "./chunk-MCVD2ZQV.mjs";
+import {
+  __toESM
+} from "./chunk-75WO2NOF.mjs";
+
+// src/presets.ts
+var import_ts_morph = __toESM(require_ts_morph(), 1);
+import { execFile } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { basename, dirname, extname, join, posix, resolve } from "node:path";
+import { promisify } from "node:util";
+var run = promisify(execFile);
+var PRESET_CATEGORIES = ["hook", "proof", "turn", "cta"];
+var AUTHORED = { width: 1920, height: 1080 };
+var POSTER_WIDTH = 320;
+var POSTER_LIMIT = 20 * 1024;
+var PREVIEW_WIDTH = 480;
+var PREVIEW_LIMIT = 600 * 1024;
+var presetsDir = (flagged) => resolve(flagged ?? process.env.HIGGSEDIT_PRESETS_DIR ?? join(process.env.HIGGSEDIT_HOME ?? join(homedir(), ".higgsedit-next"), "presets"));
+function readManifest(dir = presetsDir()) {
+  const file = join(dir, "manifest.json");
+  return existsSync(file) ? JSON.parse(readFileSync(file, "utf8")).presets : void 0;
+}
+function walk(root, sub) {
+  if (!existsSync(join(root, sub))) return [];
+  return readdirSync(join(root, sub), { withFileTypes: true }).filter((e) => !e.name.startsWith(".")).flatMap((e) => e.isDirectory() ? walk(root, posix.join(sub, e.name)) : [posix.join(sub, e.name)]).toSorted();
+}
+var parser = new import_ts_morph.Project({ useInMemoryFileSystem: true, skipLoadingLibFiles: true, compilerOptions: { jsx: 1 } });
+function readComponent(text) {
+  const sf = parser.createSourceFile("/component.tsx", text, { overwrite: true });
+  const init = sf.getVariableDeclaration("info")?.getInitializer();
+  if (!init || !isLiteral(init)) throw new Error("`info` is not a plain object literal");
+  const info = literalValue(init);
+  const { category, name, description, duration } = info;
+  if (!PRESET_CATEGORIES.includes(category)) throw new Error(`info.category ${JSON.stringify(category)} is not one of ${PRESET_CATEGORIES.join(", ")}`);
+  if (typeof name !== "string" || typeof description !== "string" || typeof duration !== "number") throw new Error("info needs a string name and description and a number duration");
+  const components = sf.getFunctions().flatMap((f) => {
+    const props2 = f.getParameters()[0]?.getTypeNode()?.getText();
+    return f.isExported() && f.getName() && props2?.endsWith("Props") ? [{ name: f.getName(), props: props2 }] : [];
+  });
+  if (components.length !== 1) throw new Error(`expected one exported component taking \u2026Props, found ${components.length}`);
+  const { name: component, props } = components[0];
+  const type = sf.getTypeAlias(props)?.getTypeNode() ?? sf.getInterface(props);
+  const names = import_ts_morph.Node.isTypeLiteral(type) || import_ts_morph.Node.isInterfaceDeclaration(type) ? type.getProperties().map((m) => m.getName()) : [];
+  const adapts = names.includes("width") && names.includes("height");
+  return { category, name, description, duration, component, adapts, propsType: props, props: names };
+}
+var VIDEO_EXT = /\.(mp4|mov|webm|m4v)$/i;
+var IMAGE_EXT = /\.(png|jpe?g|webp)$/i;
+var ASPECT = /^\d+(\.\d+)?:\d+(\.\d+)?$/;
+var placeholderPath = (kind, aspect) => `_core/media/placeholder/${kind}-${aspect.replace(":", "x")}.${kind === "image" ? "jpg" : "mp4"}`;
+function fail(what) {
+  throw new Error(`slots.json: ${what}`);
+}
+var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function parseSlots(raw, ids) {
+  if (!isObject(raw)) fail("expected an object keyed by preset id");
+  for (const [id, entry] of Object.entries(raw)) {
+    if (!ids.includes(id)) fail(`no preset ${id} in the pack`);
+    if (!isObject(entry) || !Array.isArray(entry.slots) || !isObject(entry.content) || !Array.isArray(entry.texture)) fail(`${id} needs slots [], content {} and texture []`);
+    const { slots, content, texture } = entry;
+    slots.forEach((s, i) => {
+      const at = `${id}.slots[${i}]`;
+      if (!isObject(s) || typeof s.prop !== "string" || typeof s.label !== "string") fail(`${at} needs a string prop and label`);
+      if (s.kind !== "image" && s.kind !== "video") fail(`${at}.kind must be "image" or "video"`);
+      if (typeof s.aspect !== "string" || !ASPECT.test(s.aspect)) fail(`${at}.aspect must look like "16:9"`);
+      if (s.count !== void 0 && !(Number.isInteger(s.count) && s.count > 0)) fail(`${at}.count must be a positive integer`);
+    });
+    for (const [file, aspect] of Object.entries(content)) {
+      if (typeof aspect !== "string" || !ASPECT.test(aspect)) fail(`${id}.content[${file}] must be an aspect like "16:9"`);
+      if (!IMAGE_EXT.test(file) && !VIDEO_EXT.test(file)) fail(`${id}.content: ${file} is not an image or a video`);
+    }
+    if (texture.some((f) => typeof f !== "string")) fail(`${id}.texture must list paths`);
+  }
+  return raw;
+}
+function rewriteMedia(text, path, plan) {
+  const sf = parser.createSourceFile(`/rewrite${extname(path)}`, text, { overwrite: true });
+  const edits = [];
+  const referenced = [];
+  for (const node of sf.getDescendants()) {
+    if (import_ts_morph.Node.isStringLiteral(node) || import_ts_morph.Node.isNoSubstitutionTemplateLiteral(node)) {
+      const value = node.getLiteralText();
+      if (!plan.known.includes(value)) continue;
+      referenced.push(value);
+      const to = plan.rewrite.get(value);
+      const quote = node.getText()[0];
+      if (to) edits.push({ start: node.getStart(), end: node.getEnd(), text: `${quote}${to}${quote}` });
+    } else if (import_ts_morph.Node.isTemplateExpression(node)) {
+      const parts = [node.getHead().getLiteralText(), ...node.getTemplateSpans().map((s) => s.getLiteral().getLiteralText())];
+      if (!/\.\w+$/.test(parts.at(-1))) continue;
+      const pattern = new RegExp(`^${parts.map((p) => p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join(".*")}$`);
+      const matches = plan.known.filter((k) => pattern.test(k));
+      if (!matches.length) continue;
+      referenced.push(...matches);
+      const targets = matches.map((m) => plan.rewrite.get(m) ?? m);
+      if (targets.every((t, i) => t === matches[i])) continue;
+      const literal = node.getText();
+      if (matches.every((m) => plan.content.has(m)) && new Set(targets).size === 1) {
+        edits.push({ start: node.getStart(), end: node.getEnd(), text: `"${targets[0]}"` });
+      } else if (matches.every((m, i) => targets[i] === m.slice(0, -extname(m).length) + extname(targets[i])) && new Set(matches.map((m) => extname(m))).size === 1 && new Set(targets.map((t) => extname(t))).size === 1 && literal.endsWith(`${extname(matches[0])}\``)) {
+        edits.push({ start: node.getEnd() - extname(matches[0]).length - 1, end: node.getEnd() - 1, text: extname(targets[0]) });
+      } else {
+        throw new Error(`${path}: cannot rewrite ${literal}, it names ${matches.join(", ")}`);
+      }
+    }
+  }
+  let out = text;
+  for (const e of edits.toSorted((a, b) => b.start - a.start)) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  return { text: out, referenced };
+}
+var PLACEHOLDER_EDGE = 640;
+var PLACEHOLDER_SECONDS = 60;
+async function writePlaceholders(files, wanted) {
+  const { frame } = await import("./chunk-F4CMIG5G.mjs");
+  const ffmpeg = requireTool("ffmpeg");
+  const work = mkdtempSync(join(tmpdir(), "higgsedit-placeholder-"));
+  try {
+    for (const { kind, aspect } of wanted) {
+      const [w, h] = aspect.split(":").map(Number);
+      const [width, height] = w >= h ? [PLACEHOLDER_EDGE, Math.round(PLACEHOLDER_EDGE * h / w / 2) * 2] : [Math.round(PLACEHOLDER_EDGE * w / h / 2) * 2, PLACEHOLDER_EDGE];
+      const size = Math.round(Math.min(width, height) / 7);
+      writeFileSync(
+        join(work, "index.tsx"),
+        `export default () => (
+  <stage id="st">
+    <scene id="main" width={${width}} height={${height}} fps={30} fill="#808080">
+      <text id="label" y={${Math.round(height / 2 - size)}} width={${width}} align="center" fontSize={${size}} fontWeight={600} fill="#f2f2f2" end={1}>Replace me</text>
+      <text id="aspect" y={${Math.round(height / 2 + size * 0.25)}} width={${width}} align="center" fontSize={${Math.round(size * 0.55)}} fill="#d9d9d9" end={1}>${aspect} ${kind}</text>
+    </scene>
+  </stage>
+);
+`
+      );
+      const png = join(work, "frame.png");
+      await frame(work, "0", png);
+      const out = join(files, placeholderPath(kind, aspect));
+      mkdirSync(dirname(out), { recursive: true });
+      const encode = kind === "image" ? ["-i", png, "-q:v", "5", out] : ["-loop", "1", "-framerate", "1", "-i", png, "-t", String(PLACEHOLDER_SECONDS), "-c:v", "libx264", "-tune", "stillimage", "-crf", "30", "-pix_fmt", "yuv420p", "-movflags", "+faststart", out];
+      await run(ffmpeg, ["-v", "error", "-y", ...encode]);
+    }
+  } finally {
+    rmSync(work, { recursive: true, force: true });
+  }
+}
+var MAX_EDGE = 1920;
+async function writeTexture(src, files, to) {
+  const ffmpeg = requireTool("ffmpeg");
+  const stem = to.slice(0, -extname(to).length);
+  const fit = `scale='if(gte(iw,ih),min(${MAX_EDGE},iw),-2)':'if(gte(iw,ih),-2,min(${MAX_EDGE},ih))'`;
+  let out = to;
+  let args;
+  if (VIDEO_EXT.test(to)) {
+    out = `${stem}.mp4`;
+    args = ["-i", src, "-vf", `scale='min(1920,iw)':'min(1080,ih)':force_original_aspect_ratio=decrease,scale=trunc(iw/2)*2:trunc(ih/2)*2`, "-an", "-c:v", "libx264", "-crf", "28", "-pix_fmt", "yuv420p", "-movflags", "+faststart"];
+  } else if (IMAGE_EXT.test(to)) {
+    const { stdout } = await run(ffmpeg, ["-v", "error", "-i", src, "-vf", "format=rgba,alphaextract", "-f", "rawvideo", "-pix_fmt", "gray", "-"], { encoding: "buffer", maxBuffer: 1 << 28 });
+    const alpha = stdout.some((v) => v < 255);
+    const soft = stdout.reduce((n, v) => n + (v > 2 && v < 250 ? 1 : 0), 0) / stdout.length;
+    const palette = `${fit},split[a][b];[a]palettegen=reserve_transparent=1[p];[b][p]paletteuse=alpha_threshold=128`;
+    out = alpha ? `${stem}.png` : /\.jpe?g$/i.test(to) ? to : `${stem}.jpg`;
+    args = ["-i", src, ...!alpha ? ["-vf", fit, "-q:v", "5"] : soft < 0.1 ? ["-filter_complex", palette] : ["-vf", fit, "-compression_level", "9"], "-frames:v", "1"];
+  } else {
+    mkdirSync(dirname(join(files, to)), { recursive: true });
+    copyFileSync(src, join(files, to));
+    return to;
+  }
+  mkdirSync(dirname(join(files, out)), { recursive: true });
+  await run(ffmpeg, ["-v", "error", "-y", ...args, join(files, out)]);
+  if (out === to && statSync(join(files, out)).size >= statSync(src).size) copyFileSync(src, join(files, out));
+  return out;
+}
+async function smallest(out, limit, attempts) {
+  let size = 0;
+  for (const attempt of attempts) {
+    await attempt();
+    size = statSync(out).size;
+    if (size <= limit) break;
+  }
+  return size;
+}
+async function encodePoster(src, outDir, cwebp) {
+  const out = join(outDir, cwebp ? "poster.webp" : "poster.jpg");
+  const attempts = cwebp ? [80, 60, 40, 20].map((q) => () => run(cwebp, ["-quiet", "-q", String(q), "-resize", String(POSTER_WIDTH), "0", src, "-o", out])) : [3, 6, 10, 16].map((q) => () => run(requireTool("ffmpeg"), ["-v", "error", "-y", "-i", src, "-vf", `scale=${POSTER_WIDTH}:-2`, "-frames:v", "1", "-q:v", String(q), out]));
+  const size = await smallest(out, POSTER_LIMIT, attempts);
+  if (size > POSTER_LIMIT) throw new Error(`poster is ${size} bytes at the lowest quality, over ${POSTER_LIMIT}`);
+  return basename(out);
+}
+async function encodePreview(src, out) {
+  const ffmpeg = requireTool("ffmpeg");
+  const encode = (crf) => () => run(ffmpeg, ["-v", "error", "-y", "-i", src, "-vf", `scale=${PREVIEW_WIDTH}:-2`, "-an", "-c:v", "libx264", "-crf", String(crf), "-pix_fmt", "yuv420p", "-movflags", "+faststart", out]);
+  return smallest(out, PREVIEW_LIMIT, [28, 32, 36].map(encode));
+}
+async function planMedia(pack, folders, slots, files, origin) {
+  const known = [...new Set(folders.flatMap((id) => [...walk(join(pack, id), "media"), ...walk(join(pack, id), "_core/media")]))].toSorted();
+  const content = /* @__PURE__ */ new Map();
+  const wanted = /* @__PURE__ */ new Map();
+  const want = (kind, aspect) => {
+    const path = placeholderPath(kind, aspect);
+    wanted.set(path, { kind, aspect });
+    return path;
+  };
+  const textures = /* @__PURE__ */ new Map();
+  for (const [id, entry] of Object.entries(slots)) {
+    for (const [file, aspect] of Object.entries(entry.content)) {
+      const placeholder = want(VIDEO_EXT.test(file) ? "video" : "image", aspect);
+      if ((content.get(file) ?? placeholder) !== placeholder) throw new Error(`slots.json: ${file} has more than one aspect`);
+      content.set(file, placeholder);
+    }
+    for (const slot of entry.slots) want(slot.kind, slot.aspect);
+    for (const file of entry.texture) if (!textures.has(file) && existsSync(join(pack, id, file))) textures.set(file, id);
+  }
+  const both = [...textures.keys()].find((f) => content.has(f));
+  if (both) throw new Error(`slots.json: ${both} is both content and texture`);
+  await writePlaceholders(files, [...wanted.values()]);
+  const rewrite = new Map(content);
+  for (const [file, id] of textures) {
+    const to = await writeTexture(join(pack, id, file), files, file);
+    origin.set(to, readFileSync(join(pack, id, file)));
+    if (to !== file) rewrite.set(file, to);
+  }
+  return { rewrite, content, known, textures: new Set(textures.keys()) };
+}
+function importClosure(entry, paths, read) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (path) => {
+    seen.add(path);
+    const sf = parser.createSourceFile(`/closure${extname(path)}`, read(path), { overwrite: true });
+    const specs = [...sf.getImportDeclarations(), ...sf.getExportDeclarations()].map((d) => d.getModuleSpecifierValue() ?? "").filter((m) => m.startsWith("."));
+    for (const spec of specs) {
+      const base = posix.join(posix.dirname(path), spec);
+      const hit = [base, `${base}.ts`, `${base}.tsx`, `${base}/index.ts`, `${base}/index.tsx`].find((c) => paths.includes(c));
+      if (hit && !seen.has(hit)) visit(hit);
+    }
+  };
+  visit(entry);
+  return seen;
+}
+var isMedia = (path) => /^(_core\/)?media\//.test(path);
+async function installPresets(pack, dir = presetsDir(), options = { cwebp: findTool("cwebp") }) {
+  const folders = readdirSync(pack, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).toSorted();
+  const slotsFile = options.slots ?? (existsSync(join(pack, "slots.json")) ? join(pack, "slots.json") : void 0);
+  const slots = slotsFile === void 0 ? void 0 : parseSlots(JSON.parse(readFileSync(slotsFile, "utf8")), folders);
+  const staging = `${dir}.installing-${process.pid}`;
+  rmSync(staging, { recursive: true, force: true });
+  mkdirSync(join(staging, "files"), { recursive: true });
+  const result = { dir, installed: [], failed: [] };
+  const origin = /* @__PURE__ */ new Map();
+  const plan = slots && await planMedia(pack, folders, slots, join(staging, "files"), origin).catch((error) => {
+    rmSync(staging, { recursive: true, force: true });
+    throw error;
+  });
+  for (const id of folders) {
+    const root = join(pack, id);
+    try {
+      const sources = walk(root, "").filter((f) => f.endsWith(".tsx") && f !== "index.tsx" && !/^(_core|media|node_modules)\//.test(f));
+      const found = sources.filter((f) => /^export const info\b/m.test(readFileSync(join(root, f), "utf8")));
+      if (found.length !== 1) throw new Error(found.length ? `more than one file exports info: ${found.join(", ")}` : "no .tsx exports info");
+      const source = found[0];
+      const { props, propsType, ...meta } = readComponent(readFileSync(join(root, source), "utf8"));
+      const stem = basename(source, ".tsx");
+      const beside = (names) => names.map((n) => join(root, dirname(source), n)).find((f) => existsSync(f));
+      const poster = beside(["poster.jpg", `${stem}.jpg`]);
+      if (!poster) throw new Error(`no poster.jpg or ${stem}.jpg beside ${basename(source)}`);
+      const preview = beside(["preview.mp4", `${stem}.mp4`]);
+      if (!preview) throw new Error(`no preview.mp4 or ${stem}.mp4 beside ${basename(source)}`);
+      const entry = `presets/${id}/${basename(source)}`;
+      let copies = [{ to: entry, from: source }, ...[...walk(root, "media"), ...walk(root, "_core")].map((f) => ({ to: f, from: f }))];
+      const fromOf = new Map(copies.map((c) => [c.to, c.from]));
+      const imported = importClosure(entry, [...fromOf.keys()].filter((p) => /\.tsx?$/.test(p)), (p) => readFileSync(join(root, fromOf.get(p)), "utf8"));
+      copies = copies.filter((c) => !/\.tsx?$/.test(c.to) || imported.has(c.to));
+      const own = slots?.[id] ?? { slots: [], content: {}, texture: [] };
+      let presetSlots;
+      if (plan) {
+        const listed = [...Object.keys(own.content), ...own.texture].find((f) => !existsSync(join(root, f)));
+        if (listed) throw new Error(`slots.json lists ${listed}, which the preset does not have`);
+        const unknown = own.slots.find((s) => !props.includes(s.prop));
+        if (unknown) throw new Error(`slot ${unknown.prop} is not a prop of ${propsType}`);
+        const referenced = /* @__PURE__ */ new Set();
+        for (const c of copies.filter((c2) => /\.tsx?$/.test(c2.to))) {
+          const r = rewriteMedia(readFileSync(join(root, c.from), "utf8"), c.from, plan);
+          c.text = r.text;
+          for (const m of r.referenced) referenced.add(m);
+        }
+        copies = copies.flatMap((c) => {
+          if (!isMedia(c.to)) return [c];
+          if (plan.content.has(c.to)) return [];
+          if (plan.textures.has(c.to)) return [{ to: plan.rewrite.get(c.to) ?? c.to, from: c.from }];
+          return referenced.has(c.to) ? [c] : [];
+        });
+        presetSlots = own.slots.map((s) => ({ ...s, placeholder: placeholderPath(s.kind, s.aspect) }));
+        const placeholders = /* @__PURE__ */ new Set([...Object.keys(own.content).map((f) => plan.content.get(f)), ...presetSlots.map((s) => s.placeholder)]);
+        copies.push(...[...placeholders].toSorted().map((to) => ({ to })));
+      }
+      for (const { to, from } of copies) {
+        const prior = from === void 0 ? void 0 : origin.get(to);
+        if (prior && !prior.equals(readFileSync(join(root, from)))) throw new Error(`${to} differs from another preset's copy`);
+      }
+      mkdirSync(join(staging, id));
+      const posterName = await encodePoster(poster, join(staging, id), options.cwebp);
+      const previewBytes = await encodePreview(preview, join(staging, id, "preview.mp4"));
+      for (const { to, from, text } of copies) {
+        if (from === void 0 || (plan?.textures.has(from) ?? false)) continue;
+        const target = join(staging, "files", to);
+        mkdirSync(dirname(target), { recursive: true });
+        if (text === void 0) copyFileSync(join(root, from), target);
+        else writeFileSync(target, text);
+        origin.set(to, readFileSync(join(root, from)));
+      }
+      const row = {
+        id,
+        ...meta,
+        entry,
+        files: copies.map((c) => c.to),
+        poster: `${id}/${posterName}`,
+        preview: `${id}/preview.mp4`,
+        ...presetSlots ? { slots: presetSlots } : {}
+      };
+      const posterBytes = statSync(join(staging, row.poster)).size;
+      result.installed.push({ ...row, posterBytes, previewBytes });
+      options.log?.(`installed ${id}  ${row.category}  ${row.name}  ${row.duration} s  poster ${kb(posterBytes)} ${extname(posterName).slice(1)}  preview ${kb(previewBytes)}`);
+    } catch (error) {
+      result.failed.push({ id, error: error instanceof Error ? error.message : String(error) });
+      rmSync(join(staging, id), { recursive: true, force: true });
+    }
+  }
+  const presets = result.installed.map(({ posterBytes: _p, previewBytes: _v, ...row }) => row);
+  writeFileSync(join(staging, "manifest.json"), `${JSON.stringify({ presets }, null, 2)}
+`);
+  rmSync(dir, { recursive: true, force: true });
+  renameSync(staging, dir);
+  return result;
+}
+var kb = (bytes) => `${(bytes / 1024).toFixed(1)} KB`;
+var MIME = { ".webp": "image/webp", ".jpg": "image/jpeg" };
+function presetCatalogue(dir = presetsDir()) {
+  const presets = readManifest(dir);
+  return {
+    installed: presets !== void 0,
+    presets: (presets ?? []).map(({ files: _f, poster, preview: _p, ...row }) => ({
+      ...row,
+      poster: `data:${MIME[extname(poster)]};base64,${readFileSync(join(dir, poster)).toString("base64")}`,
+      preview: `/api/presets/${row.id}/preview.mp4`
+    }))
+  };
+}
+var milli = (n) => Math.round(n * 1e3) / 1e3;
+function fitInto(width, height) {
+  const scale = Math.ceil(Math.min(width / AUTHORED.width, height / AUTHORED.height) * 1e3 - 1e-9) / 1e3;
+  return { x: milli((width - AUTHORED.width * scale) / 2), y: milli((height - AUTHORED.height * scale) / 2), scale };
+}
+function copyFiles(dir, from, preset) {
+  const copied = [];
+  const skipped = [];
+  for (const file of preset.files) {
+    const source = join(from, "files", file);
+    const target = join(dir, file);
+    if (existsSync(target)) {
+      if (!readFileSync(target).equals(readFileSync(source))) skipped.push(file);
+      continue;
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    copyFileSync(source, target);
+    copied.push(file);
+  }
+  return { copied, skipped };
+}
+function fillSlots(slots, media) {
+  const target = media && slots.find((s) => s.kind === media.kind);
+  return slots.map((s) => {
+    const filled = s === target;
+    const first = filled ? media.src : s.placeholder;
+    return { prop: s.prop, src: s.count ? [first, ...Array(s.count - 1).fill(s.placeholder)] : first, filled };
+  });
+}
+function addPreset(dir, preset, at, onWrite, from = presetsDir()) {
+  const { media } = at;
+  if (media !== void 0 && !(typeof media?.src === "string" && media.src && (media.kind === "image" || media.kind === "video"))) {
+    return { ok: false, error: 'media needs a non-empty src and kind "image" or "video"' };
+  }
+  const scenes = new SourceProject(dir).byId(at.sceneId);
+  if (scenes.length !== 1) return { ok: false, error: scenes.length ? `${at.sceneId} is used more than once` : `no element ${at.sceneId}` };
+  const sceneFile = scenes[0].file.path;
+  const files = copyFiles(dir, from, preset);
+  const slots = fillSlots(preset.slots ?? [], media);
+  const fit = !preset.adapts && (at.width !== AUTHORED.width || at.height !== AUTHORED.height);
+  const module = posix.relative(posix.dirname(sceneFile), preset.entry.replace(/\.tsx$/, ""));
+  const component = {
+    op: "insert",
+    tag: preset.component,
+    props: { start: fit ? 0 : at.start, ...preset.adapts ? { width: at.width, height: at.height } : {}, ...Object.fromEntries(slots.map((s) => [s.prop, s.src])) },
+    import: { from: module.startsWith(".") ? module : `./${module}` }
+  };
+  const results = [];
+  let group = null;
+  if (fit) {
+    const { x, y, scale } = fitInto(at.width, at.height);
+    const insert = { op: "insert", tag: "group", props: { x, y, ...AUTHORED, scale, anchorX: 0, anchorY: 0, clip: true, start: at.start, end: at.start + preset.duration } };
+    results.push(applyEdit(dir, at.sceneId, insert, { onWrite }));
+    group = results[0].id ?? null;
+  }
+  if (results.every((r) => r.ok)) results.push(applyEdit(dir, group ?? at.sceneId, component, { onWrite }));
+  const ok = results.every((r) => r.ok);
+  return { ok, id: ok ? results.at(-1).id : void 0, group, ...files, slots, results };
+}
+async function runPresets(args, print) {
+  const [sub, pack] = args.positional;
+  if (sub === "install") {
+    if (!pack) throw new Error("usage: higgsedit presets install <pack-dir> [--out <dir>] [--slots <slots.json>]");
+    const slots = flag(args, "slots");
+    const out = flag(args, "out");
+    const r = await installPresets(resolve(pack), out ? resolve(out) : presetsDir(), {
+      cwebp: findTool("cwebp"),
+      slots: slots && resolve(slots),
+      ...args.flags.json === true ? {} : { log: (line) => console.log(line) }
+    });
+    for (const f of r.failed) console.error(`FAILED ${f.id}: ${f.error}`);
+    print(r, () => `${r.installed.length} presets in ${r.dir}`);
+    return r.failed.length ? 1 : 0;
+  }
+  if (sub) throw new Error("usage: higgsedit presets [--json] [--presets <dir>] | higgsedit presets install <pack-dir> [--out <dir>] [--slots <slots.json>]");
+  const manifest = readManifest(presetsDir(flag(args, "presets")));
+  const presets = manifest ?? [];
+  const listed = { installed: manifest !== void 0, presets: presets.map(({ id, category, name, duration }) => ({ id, category, name, duration })) };
+  const idWidth = Math.max(0, ...presets.map((p) => p.id.length));
+  const categoryWidth = Math.max(0, ...presets.map((p) => p.category.length));
+  print(
+    listed,
+    () => presets.length ? presets.map((p) => `${p.id.padEnd(idWidth)}  ${p.category.padEnd(categoryWidth)}  ${p.duration} s  ${p.name}`).join("\n") : "no presets installed; run `higgsedit presets install <pack-dir>`"
+  );
+  return 0;
+}
+
+export {
+  PRESET_CATEGORIES,
+  presetsDir,
+  readManifest,
+  placeholderPath,
+  installPresets,
+  presetCatalogue,
+  fitInto,
+  addPreset,
+  runPresets
+};