motionrender 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,2330 @@
+// packages/core/src/index.ts
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname3, extname as extname3, join as join9, resolve as resolve3 } from "node:path";
+
+// packages/schema/src/index.ts
+import { z as z3 } from "zod";
+
+// packages/schema/src/variables.ts
+import { z } from "zod";
+
+// packages/schema/src/expression.ts
+var operators = ["===", "!==", "==", "!=", "<=", ">=", "&&", "||", "<", ">", "+", "-", "*", "/", "%", "!", "?", ":", "(", ")", "[", "]", ".", ","];
+function tokenize(source) {
+  const tokens = [];
+  let i = 0;
+  while (i < source.length) {
+    const ch = source[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    const num3 = /^(\d+\.?\d*|\.\d+)([eE][-+]?\d+)?/.exec(source.slice(i));
+    if (num3 && !(ch === "." && /[A-Za-z_\])]/.test(source[i - 1] ?? ""))) {
+      tokens.push({ kind: "num", value: num3[0] });
+      i += num3[0].length;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      let value = "", j = i + 1;
+      while (j < source.length && source[j] !== ch) {
+        if (source[j] === "\\" && j + 1 < source.length) j++;
+        value += source[j];
+        j++;
+      }
+      if (j >= source.length) throw new Error("unclosed quote");
+      tokens.push({ kind: "str", value });
+      i = j + 1;
+      continue;
+    }
+    const name2 = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(i));
+    if (name2) {
+      tokens.push({ kind: "name", value: name2[0] });
+      i += name2[0].length;
+      continue;
+    }
+    const op = operators.find((o) => source.startsWith(o, i));
+    if (op) {
+      tokens.push({ kind: "op", value: op });
+      i += op.length;
+      continue;
+    }
+    throw new Error(`unexpected "${ch}"`);
+  }
+  return tokens;
+}
+function parse(source) {
+  const tokens = tokenize(source);
+  let pos = 0;
+  const peek = (value) => {
+    const t = tokens[pos];
+    return t && (value === void 0 || t.kind === "op" && t.value === value) ? t : void 0;
+  };
+  const expect = (value) => {
+    if (!peek(value)) throw new Error(`expected "${value}"${tokens[pos] ? ` before "${tokens[pos].value}"` : " at the end"}`);
+    pos++;
+  };
+  const binary = (next, ops) => () => {
+    let left = next();
+    while (tokens[pos]?.kind === "op" && ops.includes(tokens[pos].value)) {
+      const op = tokens[pos++].value;
+      left = { kind: "binary", op, left, right: next() };
+    }
+    return left;
+  };
+  const primary = () => {
+    const t = tokens[pos++];
+    if (!t) throw new Error("expression ended early");
+    if (t.kind === "num") return { kind: "lit", value: Number(t.value) };
+    if (t.kind === "str") return { kind: "lit", value: t.value };
+    if (t.kind === "name") {
+      if (t.value === "true" || t.value === "false") return { kind: "lit", value: t.value === "true" };
+      if (t.value === "null") return { kind: "lit", value: null };
+      if (peek("(")) {
+        pos++;
+        const args = [];
+        if (!peek(")")) {
+          args.push(ternary());
+          while (peek(",")) {
+            pos++;
+            args.push(ternary());
+          }
+        }
+        expect(")");
+        return { kind: "call", name: t.value, args };
+      }
+      return { kind: "name", name: t.value };
+    }
+    if (t.value === "(") {
+      const inner = ternary();
+      expect(")");
+      return inner;
+    }
+    throw new Error(`unexpected "${t.value}"`);
+  };
+  const postfix = () => {
+    let node2 = primary();
+    for (; ; ) {
+      if (peek(".")) {
+        pos++;
+        const t = tokens[pos++];
+        if (t?.kind !== "name") throw new Error('expected a field name after "."');
+        node2 = { kind: "member", target: node2, key: { kind: "lit", value: t.value } };
+      } else if (peek("[")) {
+        pos++;
+        const key = ternary();
+        expect("]");
+        node2 = { kind: "member", target: node2, key };
+      } else return node2;
+    }
+  };
+  const unary = () => {
+    if (peek("!") || peek("-")) {
+      const op = tokens[pos++].value;
+      return { kind: "unary", op, arg: unary() };
+    }
+    return postfix();
+  };
+  const mul = binary(unary, ["*", "/", "%"]), add = binary(mul, ["+", "-"]), rel = binary(add, ["<", "<=", ">", ">="]), eq = binary(rel, ["==", "!=", "===", "!=="]), and = binary(eq, ["&&"]), or = binary(and, ["||"]);
+  function ternary() {
+    const test = or();
+    if (!peek("?")) return test;
+    pos++;
+    const then = ternary();
+    expect(":");
+    return { kind: "cond", test, then, else: ternary() };
+  }
+  const node = ternary();
+  if (pos < tokens.length) throw new Error(`unexpected "${tokens[pos].value}"`);
+  return node;
+}
+var num = (v, what) => {
+  if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`${what} needs a number, got ${JSON.stringify(v)}`);
+  return v;
+};
+var functions = {
+  round: (x, d = 0) => {
+    const f = 10 ** num(d, "round");
+    return Math.round(num(x, "round") * f) / f;
+  },
+  floor: (x) => Math.floor(num(x, "floor")),
+  ceil: (x) => Math.ceil(num(x, "ceil")),
+  abs: (x) => Math.abs(num(x, "abs")),
+  min: (...xs) => Math.min(...xs.map((x) => num(x, "min"))),
+  max: (...xs) => Math.max(...xs.map((x) => num(x, "max"))),
+  upper: (s) => String(s).toUpperCase(),
+  lower: (s) => String(s).toLowerCase(),
+  string: (v) => String(v),
+  number: (v) => num(Number(v), "number")
+};
+var blocked = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+function member(target, key) {
+  if ((Array.isArray(target) || typeof target === "string") && key === "length") return target.length;
+  if (Array.isArray(target)) {
+    if (typeof key !== "number" || !Number.isInteger(key)) throw new Error(`lists are indexed by whole numbers, got ${JSON.stringify(key)}`);
+    return target[key];
+  }
+  if (target && typeof target === "object" && typeof key === "string" && !blocked.has(key)) {
+    if (!Object.hasOwn(target, key)) throw new Error(`no field "${key}"`);
+    return target[key];
+  }
+  throw new Error(`cannot read "${String(key)}" of ${target === null ? "null" : typeof target}`);
+}
+function evaluate(node, scope) {
+  switch (node.kind) {
+    case "lit":
+      return node.value;
+    case "name":
+      if (!Object.hasOwn(scope, node.name)) throw new Error(`unknown variable "${node.name}"`);
+      return scope[node.name];
+    case "member":
+      return member(evaluate(node.target, scope), evaluate(node.key, scope));
+    case "call": {
+      const own = Object.hasOwn(scope, node.name) && typeof scope[node.name] === "function" ? scope[node.name] : void 0, fn = functions[node.name] ?? own;
+      if (!fn) throw new Error(`unknown function "${node.name}" (available: ${[...Object.keys(functions), ...Object.keys(scope).filter((k) => typeof scope[k] === "function")].join(", ")})`);
+      return fn(...node.args.map((a) => evaluate(a, scope)));
+    }
+    case "unary": {
+      const v = evaluate(node.arg, scope);
+      return node.op === "!" ? !v : -num(v, "minus");
+    }
+    case "cond":
+      return evaluate(node.test, scope) ? evaluate(node.then, scope) : evaluate(node.else, scope);
+    case "binary": {
+      if (node.op === "&&") return evaluate(node.left, scope) && evaluate(node.right, scope);
+      if (node.op === "||") return evaluate(node.left, scope) || evaluate(node.right, scope);
+      const a = evaluate(node.left, scope), b = evaluate(node.right, scope);
+      switch (node.op) {
+        case "==":
+        case "===":
+          return a === b;
+        case "!=":
+        case "!==":
+          return a !== b;
+        case "+":
+          return typeof a === "string" || typeof b === "string" ? String(a) + String(b) : num(a, "+") + num(b, "+");
+        case "-":
+          return num(a, "-") - num(b, "-");
+        case "*":
+          return num(a, "*") * num(b, "*");
+        case "/":
+          return num(a, "/") / num(b, "/");
+        case "%":
+          return num(a, "%") % num(b, "%");
+        case "<":
+          return num(a, "<") < num(b, "<");
+        case "<=":
+          return num(a, "<=") <= num(b, "<=");
+        case ">":
+          return num(a, ">") > num(b, ">");
+        default:
+          return num(a, ">=") >= num(b, ">=");
+      }
+    }
+  }
+}
+var parsed = /* @__PURE__ */ new Map();
+function evaluateExpression(source, scope) {
+  let node = parsed.get(source);
+  if (!node) {
+    node = parse(source);
+    parsed.set(source, node);
+  }
+  return evaluate(node, scope);
+}
+
+// packages/schema/src/variables.ts
+var colorPattern = /^(#[0-9a-fA-F]{3,8}|rgba?\(.+\)|transparent)$/;
+var name = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/, "Names use letters, digits and _");
+var scalarTypes = ["string", "number", "boolean", "color"];
+var listFieldSchema = z.object({ type: z.enum(scalarTypes), default: z.union([z.string(), z.number(), z.boolean()]).optional(), description: z.string().optional() });
+var variableSchema = z.object({
+  type: z.enum([...scalarTypes, "list"]),
+  default: z.union([z.string(), z.number(), z.boolean(), z.array(z.record(z.string(), z.unknown()))]).optional(),
+  description: z.string().optional(),
+  items: z.record(name, listFieldSchema).optional().describe("list only: the fields each item has, checked and given defaults like variables")
+});
+var variablesSchema = z.record(name, variableSchema);
+var componentSchema = z.object({ description: z.string().optional(), params: variablesSchema.default({}), layers: z.array(z.unknown()) });
+var componentsSchema = z.record(name, componentSchema);
+var VariableError = class extends Error {
+  constructor(problems) {
+    super(`Variables:
+  ${problems.join("\n  ")}`);
+    this.problems = problems;
+  }
+  problems;
+};
+function coerceVariable(label, declaration, value) {
+  const fail = (expected) => {
+    throw new Error(`${label}: expected ${expected}, got ${JSON.stringify(value)}`);
+  };
+  switch (declaration.type) {
+    case "number": {
+      const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+      return Number.isFinite(n) ? n : fail("a number");
+    }
+    case "boolean":
+      return value === true || value === "true" ? true : value === false || value === "false" ? false : fail("true or false");
+    case "color":
+      return typeof value === "string" && colorPattern.test(value) ? value : fail("a colour such as #ff0000 or rgba(0,0,0,0.5)");
+    case "string":
+      return typeof value === "string" ? value : typeof value === "number" || typeof value === "boolean" ? String(value) : fail("text");
+    case "list": {
+      let list = value;
+      if (typeof list === "string") {
+        try {
+          list = JSON.parse(list);
+        } catch {
+          fail('a JSON list such as [{"name":"A"}]');
+        }
+      }
+      if (!Array.isArray(list) || !list.every((item) => item && typeof item === "object" && !Array.isArray(item))) return fail("a list of objects");
+      const fields = declaration.items;
+      if (!fields) return list;
+      return list.map((item, i) => {
+        for (const key of Object.keys(item)) if (!(key in fields)) throw new Error(`${label}[${i}].${key}: not declared in "items" (declared: ${Object.keys(fields).join(", ")})`);
+        return Object.fromEntries(Object.entries(fields).map(([field, decl]) => {
+          const v = field in item ? item[field] : decl.default;
+          if (v === void 0) throw new Error(`${label}[${i}].${field}: no value and no default`);
+          return [field, coerceVariable(`${label}[${i}].${field}`, decl, v)];
+        }));
+      });
+    }
+  }
+}
+function resolveVariables(declarations, supplied = {}) {
+  const problems = [], values = {};
+  for (const key of Object.keys(supplied)) if (!(key in declarations)) problems.push(`${key}: not declared in "variables"${Object.keys(declarations).length ? ` (declared: ${Object.keys(declarations).join(", ")})` : ""}`);
+  for (const [key, declaration] of Object.entries(declarations)) {
+    const value = key in supplied ? supplied[key] : declaration.default;
+    if (value === void 0) {
+      problems.push(`${key}: no value given and no default`);
+      continue;
+    }
+    try {
+      values[key] = coerceVariable(key, declaration, value);
+    } catch (error) {
+      problems.push(error.message);
+    }
+  }
+  if (problems.length) throw new VariableError(problems);
+  return values;
+}
+var wholeReference = /^\{\{((?:(?!\}\})[\s\S])*)\}\}$/;
+var reference = /\{\{((?:(?!\}\})[\s\S])*)\}\}/g;
+var expandableLists = /* @__PURE__ */ new Set(["layers", "children", "scenes", "each"]);
+var truthy = (v) => Array.isArray(v) ? v.length > 0 : !!v;
+var asText = (v) => v !== null && typeof v === "object" ? JSON.stringify(v) : String(v);
+var plain = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+var omit = (o, ...keys) => Object.fromEntries(Object.entries(o).filter(([k]) => !keys.includes(k)));
+function substituteVariables(raw, values, extra = {}) {
+  const problems = [];
+  const components = plain(raw) && raw.components !== void 0 ? componentsSchema.safeParse(raw.components) : void 0;
+  if (components && !components.success) problems.push(`components: ${components.error.issues.map((i) => `${i.path.join(".")} ${i.message}`).join("; ")}`);
+  const defs = components?.success ? components.data : {};
+  const evaluate2 = (source, scope, path) => {
+    try {
+      return evaluateExpression(source.trim(), scope);
+    } catch (error) {
+      problems.push(`${path}: {{${source.trim()}}}: ${error.message}`);
+      return void 0;
+    }
+  };
+  const text = (value, scope, path) => {
+    const whole = wholeReference.exec(value);
+    if (whole) {
+      const result2 = evaluate2(whole[1], scope, path);
+      return result2 === void 0 ? value : result2;
+    }
+    return value.replace(reference, (match, source) => {
+      const result2 = evaluate2(source, scope, path);
+      return result2 === void 0 ? match : asText(result2);
+    });
+  };
+  const visit = (node, scope, path, stack) => {
+    if (typeof node === "string") return text(node, scope, path);
+    if (Array.isArray(node)) return expandableLists.has(path.split(".").pop().replace(/\[\d+\]$/, "")) ? expandList(node, scope, path, stack) : node.map((item, i) => visit(item, scope, `${path}[${i}]`, stack));
+    if (plain(node)) return Object.fromEntries(Object.entries(node).map(([key, value]) => [key, path === "" && (key === "variables" || key === "components" || key === "$schema") ? value : visit(value, scope, path ? `${path}.${key}` : key, stack)]));
+    return node;
+  };
+  const expandList = (items, scope, path, stack) => items.flatMap((entry, i) => {
+    const at = `${path}[${i}]`;
+    if (!plain(entry)) return [visit(entry, scope, at, stack)];
+    let item = entry;
+    if ("if" in item) {
+      const condition = typeof item.if === "string" ? text(item.if, scope, `${at}.if`) : item.if;
+      if (!truthy(condition)) return [];
+      item = omit(item, "if");
+    }
+    if ("repeat" in item) {
+      const list = typeof item.repeat === "string" ? text(item.repeat, scope, `${at}.repeat`) : item.repeat;
+      const as = item.as ?? "item";
+      if (typeof as !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(as)) {
+        problems.push(`${at}.as: must be a name such as "product"`);
+        return [];
+      }
+      if (!Array.isArray(list)) {
+        if (typeof list !== "string" || !reference.test(list)) problems.push(`${at}.repeat: expected a list, got ${JSON.stringify(list)}`);
+        reference.lastIndex = 0;
+        return [];
+      }
+      if (!Array.isArray(item.each)) {
+        problems.push(`${at}.each: put the entries to repeat in "each": [ \u2026 ]`);
+        return [];
+      }
+      const body = item.each;
+      return list.flatMap((value, index) => expandList(body, { ...scope, [as]: value, index, count: list.length }, `${at}.each`, stack));
+    }
+    if ("use" in item) {
+      const component = String(item.use), def = defs[component];
+      if (!def) {
+        problems.push(`${at}.use: no component "${component}"${Object.keys(defs).length ? ` (defined: ${Object.keys(defs).join(", ")})` : ""}`);
+        return [];
+      }
+      if (stack.includes(component)) {
+        problems.push(`${at}.use: component "${component}" uses itself (${[...stack, component].join(" \u2192 ")})`);
+        return [];
+      }
+      if ("type" in item) {
+        problems.push(`${at}: a placed component is always a group; remove "type"`);
+        return [];
+      }
+      const given = visit(item.with ?? {}, scope, `${at}.with`, stack);
+      let params = {};
+      try {
+        params = resolveVariables(def.params, plain(given) ? given : {});
+      } catch (error) {
+        for (const problem of error.problems ?? [error.message]) problems.push(`${at}.with.${problem}`);
+        return [];
+      }
+      return [{ ...visit(omit(item, "use", "with"), scope, at, stack), type: "group", children: expandList(def.layers, { ...extra, ...values, ...params }, `components.${component}.layers`, [...stack, component]) }];
+    }
+    return [visit(item, scope, at, stack)];
+  });
+  const result = visit(raw, { ...extra, ...values }, "", []);
+  if (problems.length) throw new VariableError(problems);
+  return result;
+}
+var interpolate = (template, values) => substituteVariables(template, values);
+
+// packages/schema/src/captions.ts
+import { z as z2 } from "zod";
+var captionWordSchema = z2.object({ text: z2.string(), start: z2.number().nonnegative(), end: z2.number().nonnegative() });
+var captionCueSchema = z2.object({ text: z2.string(), start: z2.number().nonnegative(), end: z2.number().nonnegative(), words: z2.array(captionWordSchema).optional() });
+var clock = (value) => {
+  const m = /^(?:(\d+):)?(\d{1,2}):(\d{1,2})[.,](\d{1,3})$/.exec(value.trim());
+  if (!m) throw new Error(`Bad caption time "${value}"`);
+  return Number(m[1] ?? 0) * 3600 + Number(m[2]) * 60 + Number(m[3]) + Number(m[4].padEnd(3, "0")) / 1e3;
+};
+function parseTimedText(text) {
+  const cues = [];
+  for (const block of text.replace(/\r/g, "").split(/\n{2,}/)) {
+    const lines = block.split("\n").filter((l) => l.trim());
+    const at = lines.findIndex((l) => l.includes("-->"));
+    if (at < 0) continue;
+    const [from, to] = lines[at].split("-->").map((s) => s.trim().split(/\s+/)[0]);
+    const body = lines.slice(at + 1).join(" ").replace(/<[^>]+>/g, "").replace(/\{[^}]+\}/g, "").trim();
+    if (body) cues.push({ text: body, start: clock(from), end: clock(to) });
+  }
+  return cues;
+}
+function groupCaptionWords(words, maxWords = 7) {
+  const cues = [];
+  let line = [];
+  const flush = () => {
+    if (line.length) cues.push({ text: line.map((w) => w.text).join(" "), start: line[0].start, end: line[line.length - 1].end, words: line });
+    line = [];
+  };
+  words.forEach((word, i) => {
+    line.push(word);
+    const next = words[i + 1];
+    if (!next || /[.!?]["')\]]?$/.test(word.text) || /[,;:]["')\]]?$/.test(word.text) && line.length >= 3 || next.start - word.end > 0.35 || line.length >= maxWords) flush();
+  });
+  return cues;
+}
+function parseCaptions(text, name2 = "", maxWords = 7) {
+  const trimmed = text.trim().replace(/^/, "");
+  if (/\.json$/i.test(name2) || trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    const data = JSON.parse(trimmed);
+    const list = Array.isArray(data) ? data : data.cues ?? data.words;
+    if (!Array.isArray(list)) throw new Error('Caption JSON needs "words" or "cues" (or a list of them)');
+    const isWords = !Array.isArray(data) ? !!data.words && !data.cues : list.every((item) => typeof item?.text === "string" && !/\s/.test(item.text.trim()));
+    return isWords ? groupCaptionWords(z2.array(captionWordSchema).parse(list), maxWords) : z2.array(captionCueSchema).parse(list);
+  }
+  return parseTimedText(trimmed);
+}
+var stamp = (seconds3, separator) => {
+  const ms = Math.max(0, Math.round(seconds3 * 1e3));
+  const h = Math.floor(ms / 36e5), m = Math.floor(ms / 6e4) % 60, s = Math.floor(ms / 1e3) % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}${separator}${String(ms % 1e3).padStart(3, "0")}`;
+};
+function formatCaptions(cues, format) {
+  const body = cues.map((cue, i) => `${format === "srt" ? `${i + 1}
+` : ""}${stamp(cue.start, format === "srt" ? "," : ".")} --> ${stamp(cue.end, format === "srt" ? "," : ".")}
+${cue.text}`).join("\n\n");
+  return (format === "vtt" ? "WEBVTT\n\n" : "") + body + "\n";
+}
+var fillers = /* @__PURE__ */ new Set(["um", "umm", "uh", "uhh", "uhm", "er", "erm", "ah", "ahh", "hmm", "mm", "mhm"]);
+var captionKey = (word) => word.toLowerCase().replace(/[^\p{L}\p{N}']+/gu, "");
+function dropFillerWords(cues) {
+  return cues.map((cue) => {
+    if (cue.words?.length) {
+      const words = cue.words.filter((w, i, all) => {
+        const k = captionKey(w.text);
+        return k !== "" && !fillers.has(k) && !(i > 0 && captionKey(all[i - 1].text) === k && !/[.,!?;:]$/.test(all[i - 1].text));
+      });
+      return { ...cue, words, text: words.map((w) => w.text).join(" ") };
+    }
+    return { ...cue, text: cue.text.split(/\s+/).filter((w) => !fillers.has(captionKey(w))).join(" ") };
+  }).filter((cue) => cue.text.trim() !== "");
+}
+var captionLines = (cues, maxWords) => cues.flatMap((cue) => cue.words && cue.words.length > maxWords ? groupCaptionWords(cue.words, maxWords) : [cue]);
+
+// packages/schema/src/index.ts
+var color = z3.string().regex(colorPattern);
+var fontWeight = z3.union([z3.number().int().min(1).max(1e3), z3.enum(["normal", "bold"])]);
+var fontStyle = z3.enum(["normal", "italic"]);
+var easingSchema = z3.union([z3.enum(["linear", "easeIn", "easeOut", "easeInOut", "easeInCubic", "easeOutCubic", "easeInOutCubic", "easeInQuart", "easeOutQuart", "easeInOutQuart", "easeInExpo", "easeOutExpo", "easeInOutExpo", "easeInBack", "easeOutBack", "spring", "hold", "land", "snap", "glide", "pop", "move", "exit", "drift"]).describe("land, snap, glide and pop for entries, move within the frame, exit for leaving, drift for slow continuous motion; or a standard curve"), z3.tuple([z3.number().min(0).max(1), z3.number(), z3.number().min(0).max(1), z3.number()]).describe("Cubic B\xE9zier control points [x1, y1, x2, y2], as in CSS")]);
+var colorProperties = ["fill", "color", "stroke"];
+var cssVariableName = /^--[a-zA-Z][\w-]*$/;
+var animation = z3.object({ property: z3.union([z3.enum(["x", "y", "opacity", "rotation", "scale", "fontSize", "width", "height", "radius", "letterSpacing", "strokeWidth", "trimStart", "trimEnd", "blur", "volume", "d", ...colorProperties]), z3.string().regex(cssVariableName)]).describe("A layer property, or a CSS variable such as --progress (html layers)"), keyframes: z3.array(z3.object({ frame: z3.number().int().nonnegative(), value: z3.union([z3.number(), z3.string()]).describe("A number; a colour for fill, color and stroke; SVG path data for d (shape morphing)"), easing: easingSchema.optional().describe("Curve of the segment arriving at this keyframe") })).min(1), repeat: z3.number().int().nonnegative().optional(), reverse: z3.boolean().optional() }).superRefine((a, ctx) => {
+  if (a.property.startsWith("--")) {
+    a.keyframes.forEach((k, i) => {
+      if (typeof k.value === "string" && !colorPattern.test(k.value)) ctx.addIssue({ code: "custom", path: ["keyframes", i, "value"], message: `${a.property} keyframes need numbers or colours (they are interpolated)` });
+    });
+    return;
+  }
+  const wantsColor = colorProperties.includes(a.property), wantsPath = a.property === "d";
+  a.keyframes.forEach((k, i) => {
+    const ok = wantsPath ? typeof k.value === "string" && k.value.trim() !== "" : wantsColor ? typeof k.value === "string" && colorPattern.test(k.value) : typeof k.value === "number";
+    if (!ok) ctx.addIssue({ code: "custom", path: ["keyframes", i, "value"], message: wantsPath ? "d keyframes need SVG path data" : wantsColor ? `${a.property} keyframes need colour values` : `${a.property} keyframes need numbers` });
+  });
+});
+var origin = z3.union([z3.number(), z3.literal("center")]).default(0);
+var point = z3.tuple([z3.number(), z3.number()]);
+var stops = z3.array(z3.object({ offset: z3.number().min(0).max(1), color })).min(2);
+var gradientSchema = z3.discriminatedUnion("type", [z3.object({ type: z3.literal("linear"), from: point, to: point, stops }), z3.object({ type: z3.literal("radial"), center: point, radius: z3.number().positive(), stops })]);
+var paint = z3.union([color, gradientSchema]);
+var strokeFields = { stroke: paint.optional().describe("Outline colour or gradient"), strokeWidth: z3.number().nonnegative().default(1), strokeDash: z3.array(z3.number().nonnegative()).optional().describe("Dash and gap lengths, e.g. [12, 6]"), lineCap: z3.enum(["butt", "round", "square"]).default("butt"), lineJoin: z3.enum(["miter", "round", "bevel"]).default("miter") };
+var duckSchema = z3.object({ amount: z3.number().min(0).max(1).default(0.3).describe("Volume multiplier while ducked, e.g. 0.3"), attackFrames: z3.number().int().nonnegative().default(6).describe("Frames to fade down before a sound starts"), releaseFrames: z3.number().int().nonnegative().default(15).describe("Frames to come back up after it ends"), by: z3.array(z3.string()).optional().describe("Only duck under these layer ids") });
+var splitPresets = ["rise", "fade", "pop", "blur", "slide", "drop", "typewriter"];
+var unitProperties = ["x", "y", "opacity", "scale", "rotation", "blur", "color"];
+var splitSchema = z3.object({
+  by: z3.enum(["words", "letters", "lines"]).default("words"),
+  stagger: z3.number().nonnegative().default(3).describe("Frames between one piece starting and the next"),
+  order: z3.enum(["forward", "reverse", "center", "edges", "random"]).default("forward").describe("center starts in the middle and spreads out; edges starts at both ends; random is shuffled the same way every render"),
+  preset: z3.enum(splitPresets).default("rise").describe("rise: up into place; fade; pop: grows in with a small overshoot; blur: comes into focus; slide: in from the right; drop: down into place; typewriter: appears at once (use with letters)"),
+  duration: z3.number().int().positive().default(18).describe("Frames each piece takes to arrive, for presets"),
+  animations: z3.array(animation).optional().describe("Custom animation for every piece, replacing the preset: x, y, opacity, scale, rotation, blur or color")
+}).superRefine((s, ctx) => {
+  (s.animations ?? []).forEach((a, i) => {
+    if (!unitProperties.includes(a.property)) ctx.addIssue({ code: "custom", path: ["animations", i, "property"], message: `Pieces of split text can animate ${unitProperties.join(", ")}, not ${a.property}` });
+  });
+});
+var spanSchema = z3.object({ text: z3.string(), color: paint.optional(), fontSize: z3.number().positive().optional(), fontWeight: fontWeight.optional(), fontStyle: fontStyle.optional(), fontFamily: z3.string().optional(), background: color.optional().describe("Highlight behind the span"), underline: z3.boolean().optional() });
+var cssFilter = z3.string().regex(/^\s*((blur|brightness|contrast|grayscale|hue-rotate|invert|opacity|saturate|sepia|drop-shadow)\([^()]*(\([^()]*\)[^()]*)*\)\s*)+$/, 'Use CSS filter functions such as "brightness(1.2) saturate(0.5)"');
+var blendModes = ["normal", "multiply", "screen", "overlay", "darken", "lighten", "color-dodge", "color-burn", "hard-light", "soft-light", "difference", "exclusion", "hue", "saturation", "color", "luminosity"];
+var sfxNames = ["click", "tick", "pop", "whoosh", "thump", "ding", "riser"];
+var isBuiltinSound = (src) => src.startsWith("sfx:");
+var builtinSoundName = (src) => src.slice(4);
+var gradeLooks = ["warm", "cool", "cinematic", "teal-orange", "noir", "vivid", "faded"];
+var gradeSchema = z3.object({
+  look: z3.enum(gradeLooks).optional().describe("A starting look; the other numbers are added to it"),
+  exposure: z3.number().min(-3).max(3).optional().describe("Brightness in stops: 1 doubles the light"),
+  contrast: z3.number().min(-1).max(1).optional(),
+  saturation: z3.number().min(-1).max(1).optional().describe("-1 is black and white"),
+  temperature: z3.number().min(-1).max(1).optional().describe("Negative cooler (blue), positive warmer (orange)"),
+  tint: z3.number().min(-1).max(1).optional().describe("Negative greener, positive more magenta"),
+  shadows: z3.number().min(-1).max(1).optional().describe("Lift (positive) or crush (negative) the dark tones"),
+  highlights: z3.number().min(-1).max(1).optional().describe("Boost (positive) or pull back (negative) the bright tones"),
+  fade: z3.number().min(0).max(1).optional().describe("Raise the blacks for a faded film look")
+}).describe("Colour grading: exposure, contrast, saturation, white balance, shadows and highlights, or a look. Not animatable; cross-fade two graded layers to change it over time.");
+var baseLayer = z3.object({
+  id: z3.string().min(1),
+  type: z3.enum(["text", "image", "video", "audio", "captions", "rect", "circle", "path", "group", "html", "lottie", "shader", "code", "react"]),
+  grade: gradeSchema.optional().describe("Colour grading for this layer and everything inside it."),
+  matte: z3.object({ src: z3.string().min(1).describe("A video or picture, as an asset id or path: made with any tool (rembg, Robust Video Matting, a video editor)"), mode: z3.enum(["luma", "alpha"]).default("luma").describe("luma: white keeps the layer, black hides it; alpha: the matte's own transparency"), invert: z3.boolean().default(false).describe("Keep what the matte hides"), type: z3.enum(["video", "image"]).optional().describe("Left out, picture file extensions mean image, anything else video"), trimStart: z3.number().int().nonnegative().optional().describe("Frames of a video matte to skip; a video layer's matte follows its own trim and speed"), playbackRate: z3.number().positive().max(16).optional().describe("Speed of a video matte; a tiny value holds one frame") }).optional().describe("Show this layer only where a matte says so (a cut-out of the speaker, a shape, a gradient). Becomes a masking group when the composition loads."),
+  shadow: z3.object({ color, blur: z3.number().nonnegative().default(0), offsetX: z3.number().default(0), offsetY: z3.number().default(0) }).optional().describe("Drop shadow; offsets are in canvas pixels and ignore the layer's scale and rotation"),
+  blur: z3.number().nonnegative().default(0).describe("Gaussian blur in pixels"),
+  filter: cssFilter.optional(),
+  blendMode: z3.enum(blendModes).default("normal").describe("How the layer mixes with what is drawn below it"),
+  startFrame: z3.number().int().nonnegative().default(0),
+  endFrame: z3.number().int().positive().optional(),
+  x: z3.number().default(0),
+  y: z3.number().default(0),
+  width: z3.number().positive().optional(),
+  height: z3.number().positive().optional(),
+  opacity: z3.number().min(0).max(1).default(1),
+  rotation: z3.number().default(0),
+  scale: z3.number().positive().default(1),
+  originX: origin,
+  originY: origin,
+  zIndex: z3.number().int().default(0),
+  visible: z3.boolean().default(true),
+  fixed: z3.boolean().default(false).describe("Stays in place when the scene camera moves: captions, logos, overlays (top-level scene layers only)"),
+  animations: z3.array(animation).default([])
+});
+var outputFormats = ["mp4", "webm", "mov", "gif", "png"];
+var exportSchema = z3.object({
+  format: z3.enum(outputFormats).default("mp4"),
+  codec: z3.enum(["h264", "h265"]).default("h264").describe("mp4 only"),
+  transparent: z3.boolean().default(false).describe("Leave the background transparent (webm, mov, png only)"),
+  audio: z3.string().optional().describe("Audio asset id, or a path relative to the composition file"),
+  audioVolume: z3.number().min(0).max(4).default(1).describe("Volume of export.audio"),
+  duck: duckSchema.optional().describe("Duck export.audio under the other sounds"),
+  loudness: z3.number().min(-40).max(-5).optional().describe("Make the sound this loud overall, in LUFS: -14 for most streaming and social sites, -16 for podcasts and spoken explainers. Peaks are limited to about -1.5 dBFS"),
+  crf: z3.number().int().min(0).max(63).optional().describe("Constant quality: lower is better and larger (defaults: 20 H.264, 24 H.265, 32 VP9)"),
+  bitrate: z3.string().regex(/^\d+(\.\d+)?[kKmMgG]?$/, 'Use a number with k, M or G, e.g. "8M" or "256k"').optional().describe('Target video data rate such as "8M"; wins over crf'),
+  audioBitrate: z3.string().regex(/^\d+(\.\d+)?[kKmMgG]?$/, 'Use a number with k, M or G, e.g. "8M" or "256k"').optional().describe('Audio data rate such as "256k"'),
+  scale: z3.number().gt(0).max(4).default(1).describe("Render at this fraction of the size, e.g. 0.5 for fast drafts (sizes round to even numbers)")
+}).superRefine((e, ctx) => {
+  if (e.transparent && !["webm", "mov", "png"].includes(e.format)) ctx.addIssue({ code: "custom", path: ["transparent"], message: `${e.format} cannot store transparency; use webm, mov or png` });
+  if (e.codec !== "h264" && e.format !== "mp4") ctx.addIssue({ code: "custom", path: ["codec"], message: "codec applies to mp4 only" });
+});
+var transitionSchema = z3.object({
+  type: z3.enum(["fade", "slide", "wipe", "zoom", "iris", "push", "dip", "blur"]).describe("iris: a circle opening (or closing) on x, y; push: comes in and pushes the scene before it out the same way (transitionIn only); dip: through a colour; blur: in or out of focus"),
+  durationFrames: z3.number().int().positive(),
+  direction: z3.enum(["left", "right", "top", "bottom"]).default("left").describe("slide/wipe/push: the side the scene enters from, or exits towards"),
+  color: color.default("#000000").describe("dip: the colour passed through"),
+  x: z3.number().optional().describe("iris: centre of the circle (default: the frame centre)"),
+  y: z3.number().optional(),
+  easing: easingSchema.default("easeInOut")
+});
+var layerSchema = z3.discriminatedUnion("type", [
+  baseLayer.extend({
+    type: z3.literal("text"),
+    content: z3.string().default("").describe("The text; leave out when using spans"),
+    spans: z3.array(spanSchema).optional().describe("Rich text: styled pieces laid out together, used instead of content"),
+    fontSize: z3.number().positive().default(48),
+    fontFamily: z3.string().default("Inter").describe("An installed font, the family of a font asset, or a comma-separated list"),
+    fontWeight: fontWeight.default(400),
+    fontStyle: fontStyle.default("normal"),
+    letterSpacing: z3.number().default(0).describe("Extra pixels between characters"),
+    lineHeight: z3.number().positive().default(1.2),
+    color: paint.default("#ffffff"),
+    ...strokeFields,
+    lineJoin: strokeFields.lineJoin.removeDefault().default("round").describe("round avoids spikes on letter corners"),
+    textAlign: z3.enum(["left", "center", "right"]).default("left"),
+    maxWidth: z3.number().positive().optional().describe("Wrap lines to this width in pixels"),
+    maxLines: z3.number().int().positive().optional().describe("Cut to this many lines, ending in an ellipsis, unless minFontSize lets the text shrink to fit"),
+    minFontSize: z3.number().positive().optional().describe("Shrink the text, down to this size, until it fits maxWidth and maxLines without splitting words"),
+    split: splitSchema.optional().describe("Animate the text word by word, letter by letter or line by line")
+  }).superRefine((l, ctx) => {
+    if (l.split?.by === "letters" && l.spans?.length) ctx.addIssue({ code: "custom", path: ["split", "by"], message: "Rich text (spans) splits by words or lines, not letters" });
+  }),
+  // HTML and CSS drawn as part of the frame. No scripts run and nothing loads from the web: pictures come from assets (by id or path in
+  // src="…" or url(…)), fonts are Inter and the composition's font assets. vars are CSS custom properties on the root element; animate
+  // them with keyframes on "--name". --t (seconds since the layer started) and --frame are set every frame, so CSS @keyframes can be
+  // placed exactly: animation: rise 0.6s ease-out both paused; animation-delay: calc(var(--t) * -1s).
+  baseLayer.extend({
+    type: z3.literal("html"),
+    html: z3.string().describe("Markup, as in an HTML body; scripts and event handlers are removed"),
+    css: z3.string().default("").describe("A style sheet for the markup"),
+    width: z3.number().positive().describe("The box the markup is laid out in, in pixels"),
+    height: z3.number().positive(),
+    vars: z3.record(z3.string().regex(cssVariableName, "CSS variable names start with --"), z3.union([z3.number(), z3.string()])).default({}).describe('CSS custom properties set on the root, e.g. { "--accent": "#22d3ee" }'),
+    resolution: z3.number().min(0.5).max(4).default(1).describe("Raster detail: 2 keeps it sharp when scaled up or under a camera zoom (slower)")
+  }).superRefine((l, ctx) => {
+    for (const [field, text] of [["html", l.html], ["css", l.css]]) if (/(src\s*=\s*["']?|url\(\s*["']?)(https?:)?\/\//i.test(text)) ctx.addIssue({ code: "custom", path: [field], message: "html layers cannot load from the web: add the picture or font as an asset and refer to it by id or path" });
+  }),
+  // A Lottie animation (After Effects via Bodymovin, or LottieFiles), seeked to the exact frame. Expressions are not supported (they
+  // are JavaScript); pictures must be embedded in the JSON. Timing works like a video layer.
+  baseLayer.extend({
+    type: z3.literal("lottie"),
+    src: z3.string().min(1).describe("A lottie asset id, or a .json file relative to the composition"),
+    width: z3.number().positive(),
+    height: z3.number().positive(),
+    fit: z3.enum(["contain", "cover", "fill"]).default("contain"),
+    trimStart: z3.number().nonnegative().default(0).describe("Frames of the animation to skip, at the composition fps"),
+    playbackRate: z3.number().positive().max(16).default(1),
+    loop: z3.boolean().default(false).describe("Start again when it ends; otherwise it holds its last frame")
+  }),
+  // A React component drawn every frame: the bundle that `ove build video.tsx` writes renders the component for this frame to markup
+  // (react-dom/server), which is drawn like an html layer. Like code layers it runs the author's JavaScript, so it needs --allow-code.
+  baseLayer.extend({
+    type: z3.literal("react"),
+    src: z3.string().min(1).describe("The bundle ove build wrote, relative to the composition"),
+    width: z3.number().positive(),
+    height: z3.number().positive(),
+    durationInFrames: z3.number().int().positive().describe("The length useVideoConfig() reports to the component"),
+    props: z3.record(z3.string(), z3.unknown()).default({}).describe("Handed to the component as props"),
+    resolution: z3.number().min(0.5).max(4).default(1).describe("Raster detail: 2 keeps it sharp when scaled up or under a camera zoom (slower)")
+  }),
+  // JavaScript drawn onto a width × height canvas every frame: function draw(ctx, { frame, t, fps, width, height, props, api }). It runs
+  // in the page that renders the video, so unlike every other layer it can do anything JavaScript can: compositions with code layers only
+  // render when the caller says it trusts them (--allow-code), and never come from the AI layer or a pasted file. It must be a pure function
+  // of its arguments (use api.random(seed), not Math.random) or frames differ between renders.
+  baseLayer.extend({
+    type: z3.literal("code"),
+    code: z3.string().min(1).optional().describe("The JavaScript, inline: defines function draw(ctx, args)"),
+    src: z3.string().min(1).optional().describe("A .js file with the same, relative to the composition"),
+    width: z3.number().positive(),
+    height: z3.number().positive(),
+    props: z3.record(z3.string(), z3.unknown()).default({}).describe("Values handed to draw as args.props (they can use {{variables}})"),
+    resolution: z3.number().min(0.5).max(4).default(1).describe("Raster detail: 2 keeps it sharp when scaled up or under a camera zoom (slower)")
+  }).superRefine((l, ctx) => {
+    if (l.code === void 0 === (l.src === void 0)) ctx.addIssue({ code: "custom", path: ["code"], message: 'A code layer needs exactly one of "code" (inline) or "src" (a file)' });
+  }),
+  // A GLSL fragment shader filling a width × height box: time, resolution and frame are provided (and Shadertoy's iTime, iResolution,
+  // iFrame for code written as mainImage), plus each var as a uniform of the same name without the dashes (numbers as float,
+  // colours as vec4). It runs on the GPU with no access to anything else.
+  baseLayer.extend({
+    type: z3.literal("shader"),
+    fragment: z3.string().min(1).describe("GLSL ES fragment shader: a main() writing gl_FragColor, or a Shadertoy mainImage(out vec4, in vec2)"),
+    width: z3.number().positive(),
+    height: z3.number().positive(),
+    vars: z3.record(z3.string().regex(cssVariableName, "Variable names start with --"), z3.union([z3.number(), z3.string().regex(colorPattern)])).default({}).describe('Uniforms: { "--speed": 1 } becomes uniform float speed; colours become vec4'),
+    resolution: z3.number().min(0.25).max(2).default(1).describe("Render at this fraction of the size and scale up (0.5 is four times faster)")
+  }),
+  baseLayer.extend({ type: z3.literal("image"), src: z3.string().min(1), objectFit: z3.enum(["cover", "contain", "fill"]).default("cover"), radius: z3.number().nonnegative().default(0).describe("Rounded corners, clipping the picture") }),
+  baseLayer.extend({ type: z3.literal("video"), src: z3.string().min(1), objectFit: z3.enum(["cover", "contain", "fill"]).default("cover"), radius: z3.number().nonnegative().default(0).describe("Rounded corners, clipping the picture"), trimStart: z3.number().int().nonnegative().default(0).describe("Frames of the source to skip, at the composition fps"), playbackRate: z3.number().positive().max(16).default(1), loop: z3.boolean().default(false).describe("Restart from the first source frame when the source ends; otherwise hold the last frame"), volume: z3.number().min(0).max(4).default(1).describe("Volume of the clip's own sound; 1 is unchanged; animatable"), muted: z3.boolean().default(false), duck: duckSchema.optional() }),
+  baseLayer.extend({ type: z3.literal("audio"), src: z3.string().min(1).refine((src) => !isBuiltinSound(src) || sfxNames.includes(builtinSoundName(src)), { message: `Built-in sounds are ${sfxNames.map((n) => `sfx:${n}`).join(", ")}` }).describe("An audio asset id, a file relative to the composition, or a built-in sound: sfx:click, sfx:tick, sfx:pop, sfx:whoosh, sfx:thump, sfx:ding, sfx:riser"), volume: z3.number().min(0).max(4).default(1).describe("1 is unchanged, 0.5 is half, 2 is double; animatable with keyframes"), duck: duckSchema.optional(), trimStart: z3.number().int().nonnegative().default(0).describe("Frames of the source to skip, at the composition fps"), playbackRate: z3.number().positive().max(16).default(1), loop: z3.boolean().default(false).describe("Restart from the start of the source when it ends; otherwise silence"), fadeInFrames: z3.number().int().nonnegative().default(0), fadeOutFrames: z3.number().int().nonnegative().default(0) }),
+  // Captions: shows the line being spoken at each moment. With word timings the current word is highlighted; spoken words keep
+  // `color`, words still to come use `upcomingColor`. x, y is the anchor of the first line (centre for textAlign center).
+  baseLayer.extend({
+    type: z3.literal("captions"),
+    src: z3.string().min(1).describe("A captions asset id, or a .srt, .vtt or .json file relative to the composition"),
+    cues: z3.array(captionCueSchema).optional().describe("Caption lines given inline instead of a file"),
+    mode: z3.enum(["words", "lines"]).default("words").describe("words highlights the current word when word timings exist; lines shows each line in one colour"),
+    maxWords: z3.number().int().positive().default(7).describe("Longest line, in words, when grouping word timings"),
+    offset: z3.number().default(0).describe("Seconds to shift the captions by (positive = later)"),
+    fontSize: z3.number().positive().default(52),
+    fontFamily: z3.string().default("Inter"),
+    fontWeight: fontWeight.default(700),
+    fontStyle: fontStyle.default("normal"),
+    letterSpacing: z3.number().default(0),
+    lineHeight: z3.number().positive().default(1.3),
+    textAlign: z3.enum(["left", "center", "right"]).default("center"),
+    maxWidth: z3.number().positive().default(1400),
+    color: color.default("#ffffff"),
+    highlightColor: color.default("#facc15"),
+    emphasis: z3.array(z3.string()).default([]).describe("Words to stand out (any case, punctuation ignored), drawn in emphasisColor once said"),
+    emphasisColor: color.optional().describe("Colour of emphasis words; default: highlightColor"),
+    dropFillers: z3.boolean().default(true).describe("Leave out filler words (um, uh, erm\u2026) and words said twice in a row"),
+    upcomingColor: color.default("rgba(255,255,255,0.55)"),
+    background: color.default("rgba(0,0,0,0.55)").describe('Box behind the text; "transparent" for none'),
+    padding: z3.number().nonnegative().default(18),
+    radius: z3.number().nonnegative().default(14),
+    ...strokeFields,
+    lineJoin: strokeFields.lineJoin.removeDefault().default("round")
+  }),
+  baseLayer.extend({ type: z3.literal("rect"), fill: paint.default("#000000"), radius: z3.number().nonnegative().default(0), ...strokeFields }),
+  baseLayer.extend({ type: z3.literal("circle"), fill: paint.default("#000000"), ...strokeFields }),
+  baseLayer.extend({
+    type: z3.literal("path"),
+    d: z3.string().min(1).describe('SVG path data, in pixels relative to x, y, e.g. "M0 0 L200 0 L100 150 Z"'),
+    fill: paint.optional().describe("Leave out for an outline-only path"),
+    fillRule: z3.enum(["nonzero", "evenodd"]).default("nonzero"),
+    ...strokeFields,
+    trimStart: z3.number().min(0).max(1).default(0).describe("Fraction of the outline hidden at its start"),
+    trimEnd: z3.number().min(0).max(1).default(1).describe("Fraction of the outline drawn up to; animate 0 \u2192 1 to draw the line on")
+  }),
+  baseLayer.extend({
+    type: z3.literal("group"),
+    children: z3.array(z3.lazy(() => layerSchema)).default([]),
+    masked: z3.object({ mode: z3.enum(["luma", "alpha"]).default("luma"), invert: z3.boolean().default(false) }).optional().describe("The group's last child is a matte: the other children show only where it is white (luma) or opaque (alpha). Written for you by the matte property."),
+    clipPath: z3.string().min(1).optional().describe("SVG path data in the group's pixels; children are only visible inside it"),
+    layout: z3.object({
+      direction: z3.enum(["row", "column"]).default("row"),
+      gap: z3.number().nonnegative().default(0),
+      padding: z3.number().nonnegative().default(0),
+      align: z3.enum(["start", "center", "end"]).default("start").describe("Across the direction: top, middle or bottom of a row; left, centre or right of a column"),
+      justify: z3.enum(["start", "center", "end", "space-between"]).default("start").describe("Along the direction, within the group's width (row) or height (column) when set")
+    }).optional().describe("Place the children one after another, measured as drawn (text included); each child's own x and y then offset it from its place")
+  })
+]);
+var cameraSchema = z3.object({
+  x: z3.number().optional(),
+  y: z3.number().optional(),
+  zoom: z3.number().positive().default(1),
+  rotation: z3.number().default(0),
+  shake: z3.number().nonnegative().default(0).describe("Wobble in pixels, the same in every render"),
+  animations: z3.array(z3.object({ property: z3.enum(["x", "y", "zoom", "rotation", "shake"]), keyframes: z3.array(z3.object({ frame: z3.number().int().nonnegative(), value: z3.number(), easing: easingSchema.optional() })).min(1), repeat: z3.number().int().nonnegative().optional(), reverse: z3.boolean().optional() })).default([])
+});
+var sceneSchema = z3.object({ grade: gradeSchema.optional().describe("Colour grading for the whole scene (fixed layers excluded)."), id: z3.string().min(1), name: z3.string().min(1), startFrame: z3.number().int().nonnegative().default(0), overlap: z3.number().int().nonnegative().optional().describe("Frames this scene overlaps the previous one when startFrame is left out"), durationFrames: z3.number().int().positive(), metadata: z3.record(z3.string(), z3.unknown()).default({}), transitionIn: transitionSchema.optional(), transitionOut: transitionSchema.optional(), camera: cameraSchema.optional().describe("Moves, zooms and turns the view of the whole scene; layers with fixed: true stay put"), layers: z3.array(layerSchema).default([]), assetIds: z3.array(z3.string()).default([]) });
+var assetSchema = z3.object({ id: z3.string().min(1), type: z3.enum(["image", "video", "audio", "font", "svg", "captions", "lottie"]), src: z3.string().min(1), family: z3.string().min(1).optional().describe("Font assets: the family name text layers use"), weight: fontWeight.optional().describe("Font assets: the weight this file provides (default 400)"), style: fontStyle.optional().describe("Font assets: normal or italic (default normal)"), metadata: z3.record(z3.string(), z3.unknown()).default({}) });
+var tempoSchema = z3.object({ bpm: z3.number().positive().max(400), offset: z3.number().default(0).describe("Seconds from the start of the video to the first beat"), beatsPerBar: z3.number().int().positive().default(4) });
+function beatFunctions(raw) {
+  const tempo2 = tempoSchema.safeParse(raw?.tempo), fps = Number(raw?.fps);
+  const need = (name2) => () => {
+    throw new Error(`${name2}() needs a top-level "tempo": { "bpm": \u2026 } and a numeric fps`);
+  };
+  if (!tempo2.success || !(fps > 0)) return { beat: need("beat"), bar: need("bar"), beats: need("beats") };
+  const { bpm, offset, beatsPerBar } = tempo2.data, at = (n) => Math.round((offset + n * 60 / bpm) * fps), number = (v, name2) => {
+    if (typeof v !== "number" || !Number.isFinite(v)) throw new Error(`${name2}() takes numbers`);
+    return v;
+  };
+  return { beat: (n) => at(number(n, "beat")), bar: (n, b = 0) => at(number(n, "bar") * beatsPerBar + number(b, "bar")), beats: (n) => Math.round(number(n, "beats") * 60 / bpm * fps) };
+}
+var compositionSchema = z3.object({ $schema: z3.string().optional(), version: z3.literal("1.0"), id: z3.string().min(1), name: z3.string().min(1), width: z3.number().int().positive(), height: z3.number().int().positive(), fps: z3.number().int().positive().max(240), durationFrames: z3.union([z3.number().int().positive(), z3.literal("auto")]).describe('"auto" ends the video when its last scene ends').transform((v, ctx) => {
+  if (v === "auto") {
+    ctx.addIssue({ code: "custom", message: '"auto" is resolved by loadComposition; parseComposition needs a number' });
+    return z3.NEVER;
+  }
+  return v;
+}), variables: variablesSchema.default({}).describe("Template inputs; use them as {{name}} in any string"), components: componentsSchema.default({}).describe('Reusable layer sets, placed with { "use": name, "with": { \u2026 } }'), assets: z3.array(assetSchema).default([]), scenes: z3.array(sceneSchema).min(1), background: paint.default("#101827").describe("Colour or gradient behind all layers (ignored when export.transparent is true)"), motionBlur: z3.object({ samples: z3.number().int().min(2).max(32).default(8).describe("Sub-frames averaged per frame: more is smoother and slower"), shutter: z3.number().gt(0).max(360).default(180).describe("Shutter angle in degrees: 180 blurs over half a frame, the film look; 360 over a whole frame") }).optional().describe("Blur fast motion by averaging sub-frames (renders only; the live preview shows it sharp). Each frame takes samples times as long to draw"), tempo: tempoSchema.optional().describe("The music's tempo, for beat(n), bar(n) and beats(n) in expressions"), grain: z3.number().min(0).max(1).default(0).describe("Film grain over the whole frame, such as 0.06: it hides banding in dark gradients. Different each frame, the same in every render; not applied to transparent output"), export: exportSchema.default({ format: "mp4", codec: "h264", transparent: false, scale: 1, audioVolume: 1 }) }).superRefine((value, ctx) => {
+  for (const scene of value.scenes) if (scene.startFrame + scene.durationFrames > value.durationFrames) ctx.addIssue({ code: "custom", path: ["scenes"], message: `Scene ${scene.id} exceeds composition duration` });
+});
+function expandSceneGrades(input) {
+  const raw = input;
+  if (!raw || typeof raw !== "object" || !Array.isArray(raw.scenes)) return input;
+  return { ...raw, scenes: raw.scenes.map((scene) => {
+    if (!scene || typeof scene !== "object" || !scene.grade || !Array.isArray(scene.layers)) return scene;
+    const { grade, ...rest } = scene, still = scene.layers.filter((layer) => layer?.fixed), moving = scene.layers.filter((layer) => !layer?.fixed);
+    return { ...rest, layers: [{ id: `${scene.id}-graded`, type: "group", x: 0, y: 0, grade, children: moving }, ...still] };
+  }) };
+}
+var pictureFile = /\.(png|jpe?g|webp|gif|bmp)$/i;
+function expandMattes(input) {
+  const raw = input;
+  if (!raw || typeof raw !== "object" || !Array.isArray(raw.scenes)) return input;
+  const wrap = (layer) => {
+    if (!layer || typeof layer !== "object") return layer;
+    const next = Array.isArray(layer.children) ? { ...layer, children: layer.children.map(wrap) } : layer;
+    const matte = next.matte;
+    if (!matte || typeof matte !== "object" || typeof matte.src !== "string") return next;
+    const { matte: _matte, zIndex, fixed, ...inner } = next;
+    const image = (matte.type ?? (pictureFile.test(matte.src) ? "image" : "video")) === "image", follows = inner.type === "video";
+    const matteLayer = {
+      id: `${inner.id}-matte`,
+      type: image ? "image" : "video",
+      src: matte.src,
+      x: 0,
+      y: 0,
+      width: raw.width,
+      height: raw.height,
+      objectFit: "cover",
+      startFrame: inner.startFrame ?? 0,
+      ...inner.endFrame !== void 0 ? { endFrame: inner.endFrame } : {},
+      ...image ? {} : { trimStart: matte.trimStart ?? (follows ? inner.trimStart ?? 0 : 0), playbackRate: matte.playbackRate ?? (follows ? inner.playbackRate ?? 1 : 1), loop: follows ? !!inner.loop : false, muted: true, volume: 0 }
+    };
+    return { id: `${inner.id}-masked`, type: "group", x: 0, y: 0, ...zIndex !== void 0 ? { zIndex } : {}, ...fixed ? { fixed } : {}, masked: { mode: matte.mode ?? "luma", invert: !!matte.invert }, children: [inner, matteLayer] };
+  };
+  return { ...raw, scenes: raw.scenes.map((scene) => scene && Array.isArray(scene.layers) ? { ...scene, layers: scene.layers.map(wrap) } : scene) };
+}
+function parseComposition(input) {
+  return compositionSchema.parse(expandMattes(expandSceneGrades(input)));
+}
+var canvasNames = (input) => {
+  const raw = input ?? {};
+  const [width, height, fps] = [raw.width, raw.height, raw.fps];
+  return typeof width === "number" && typeof height === "number" ? { canvas: { width, height, fps: typeof fps === "number" ? fps : 30 } } : {};
+};
+function sequenceScenes(expanded) {
+  if (!expanded || typeof expanded !== "object" || !Array.isArray(expanded.scenes)) return expanded;
+  const raw = expanded;
+  let end = 0, latest = 0;
+  const scenes = raw.scenes.map((scene, i) => {
+    if (!scene || typeof scene !== "object") return scene;
+    let start = scene.startFrame;
+    if (start === void 0) start = i === 0 ? 0 : Math.max(0, end - (typeof scene.overlap === "number" ? scene.overlap : scene.transitionIn?.durationFrames ?? 0));
+    if (typeof start === "number" && typeof scene.durationFrames === "number") {
+      end = start + scene.durationFrames;
+      latest = Math.max(latest, end);
+    }
+    return { ...scene, startFrame: start };
+  });
+  return { ...raw, scenes, durationFrames: raw.durationFrames === "auto" || raw.durationFrames === void 0 ? latest || raw.durationFrames : raw.durationFrames };
+}
+function loadComposition(input, values = {}, options = {}) {
+  const declarations = variablesSchema.parse(input?.variables ?? {});
+  return parseComposition(sequenceScenes(substituteVariables(input, resolveVariables(declarations, values), { ...beatFunctions(input), ...canvasNames(input), ...options.media ? { media: options.media } : {} })));
+}
+var compositionJsonSchema = z3.toJSONSchema(compositionSchema, { target: "draft-2020-12", io: "input" });
+var describeError = (error) => error instanceof z3.ZodError ? z3.prettifyError(error) : error instanceof Error ? error.message : String(error);
+
+// packages/core/src/media.ts
+import { spawn as spawn2 } from "node:child_process";
+import { mkdir, readFile as readFile2, stat as stat2, writeFile } from "node:fs/promises";
+import { join as join3 } from "node:path";
+import { createHash } from "node:crypto";
+
+// packages/animation/src/index.ts
+var back = 1.70158;
+var roleCurves = { land: [0.16, 1, 0.3, 1], snap: [0.05, 0.9, 0.1, 1], glide: [0.25, 0.8, 0.35, 1], pop: [0.34, 1.45, 0.64, 1], move: [0.76, 0, 0.24, 1], exit: [0.5, 0, 0.75, 0], drift: [0.35, 0.15, 0.65, 0.85] };
+var springCurve = (t) => 1 - Math.exp(-7 * t) * Math.cos(3 * Math.PI * t);
+var springEnd = springCurve(1);
+function cubicBezier(x1, y1, x2, y2, t) {
+  const bez = (a, b, s2) => 3 * (1 - s2) * (1 - s2) * s2 * a + 3 * (1 - s2) * s2 * s2 * b + s2 * s2 * s2;
+  const slope = (a, b, s2) => 3 * (1 - s2) * (1 - s2) * a + 6 * (1 - s2) * s2 * (b - a) + 3 * s2 * s2 * (1 - b);
+  let s = t;
+  for (let i = 0; i < 8; i++) {
+    const error = bez(x1, x2, s) - t, d = slope(x1, x2, s);
+    if (Math.abs(error) < 1e-7) return bez(y1, y2, s);
+    if (Math.abs(d) < 1e-6) break;
+    s -= error / d;
+  }
+  let lo = 0, hi = 1;
+  s = t;
+  for (let i = 0; i < 60; i++) {
+    const x = bez(x1, x2, s);
+    if (Math.abs(x - t) < 1e-7) break;
+    if (x < t) lo = s;
+    else hi = s;
+    s = (lo + hi) / 2;
+  }
+  return bez(y1, y2, s);
+}
+function ease(t, kind = "linear") {
+  if (t <= 0) return 0;
+  if (t >= 1) return 1;
+  if (typeof kind !== "string") return cubicBezier(kind[0], kind[1], kind[2], kind[3], t);
+  switch (kind) {
+    case "easeIn":
+      return t * t;
+    case "easeOut":
+      return 1 - (1 - t) * (1 - t);
+    case "easeInOut":
+      return t < 0.5 ? 2 * t * t : 1 - Math.pow(-2 * t + 2, 2) / 2;
+    case "easeInCubic":
+      return t * t * t;
+    case "easeOutCubic":
+      return 1 - Math.pow(1 - t, 3);
+    case "easeInOutCubic":
+      return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
+    case "easeInQuart":
+      return t * t * t * t;
+    case "easeOutQuart":
+      return 1 - Math.pow(1 - t, 4);
+    case "easeInOutQuart":
+      return t < 0.5 ? 8 * t * t * t * t : 1 - Math.pow(-2 * t + 2, 4) / 2;
+    case "easeInExpo":
+      return Math.pow(2, 10 * t - 10);
+    case "easeOutExpo":
+      return 1 - Math.pow(2, -10 * t);
+    case "easeInOutExpo":
+      return t < 0.5 ? Math.pow(2, 20 * t - 10) / 2 : (2 - Math.pow(2, -20 * t + 10)) / 2;
+    case "easeInBack":
+      return (back + 1) * t * t * t - back * t * t;
+    case "easeOutBack":
+      return 1 + (back + 1) * Math.pow(t - 1, 3) + back * Math.pow(t - 1, 2);
+    case "spring":
+      return springCurve(t) / springEnd;
+    case "hold":
+      return 0;
+    default: {
+      const c = roleCurves[kind];
+      return c ? cubicBezier(c[0], c[1], c[2], c[3], t) : t;
+    }
+  }
+}
+function parseColor(value) {
+  const v = value.trim().toLowerCase();
+  if (v === "transparent") return [0, 0, 0, 0];
+  const hex = /^#([0-9a-f]{3,8})$/.exec(v);
+  if (hex && [3, 4, 6, 8].includes(hex[1].length)) {
+    const h = hex[1], full = h.length <= 4 ? [...h].map((c) => c + c).join("") : h;
+    const n = (i) => parseInt(full.slice(i, i + 2), 16);
+    return [n(0), n(2), n(4), full.length === 8 ? n(6) / 255 : 1];
+  }
+  const fn = /^rgba?\(([^)]+)\)$/.exec(v);
+  if (fn) {
+    const parts = fn[1].split(/[\s,/]+/).filter(Boolean).map((p, i) => p.endsWith("%") ? parseFloat(p) * (i === 3 ? 0.01 : 2.55) : parseFloat(p));
+    if ((parts.length === 3 || parts.length === 4) && parts.every(Number.isFinite)) return [parts[0], parts[1], parts[2], parts[3] ?? 1];
+  }
+  throw new Error(`Cannot animate colour "${value}"`);
+}
+function mixColors(from, to, t) {
+  const a = parseColor(from), b = parseColor(to), c = a.map((x, i) => x + (b[i] - x) * t);
+  return `rgba(${Math.round(c[0])},${Math.round(c[1])},${Math.round(c[2])},${Math.round(c[3] * 1e4) / 1e4})`;
+}
+function animationSegment(animation2, frame) {
+  const keys = animation2.keyframes;
+  const duration = keys.at(-1).frame;
+  let f = duration === 0 ? 0 : frame;
+  if (animation2.repeat !== void 0 && duration > 0) {
+    const cycle = Math.min(Math.floor(f / duration), animation2.repeat);
+    f = f - cycle * duration;
+    if (animation2.reverse && cycle % 2) f = duration - f;
+  }
+  if (f <= keys[0].frame) return { from: keys[0].value, to: keys[0].value, t: 0 };
+  if (f >= keys.at(-1).frame) return { from: keys.at(-1).value, to: keys.at(-1).value, t: 1 };
+  const i = keys.findIndex((k) => k.frame >= f), from = keys[i - 1], to = keys[i];
+  return { from: from.value, to: to.value, t: ease((f - from.frame) / (to.frame - from.frame), to.easing ?? "linear") };
+}
+function evaluateAnimation(animation2, frame) {
+  const keys = animation2.keyframes;
+  const duration = keys.at(-1).frame;
+  let f = duration === 0 ? 0 : frame;
+  if (animation2.repeat !== void 0 && duration > 0) {
+    const cycle = Math.min(Math.floor(f / duration), animation2.repeat);
+    f = f - cycle * duration;
+    if (animation2.reverse && cycle % 2) f = duration - f;
+  }
+  if (f <= keys[0].frame) return keys[0].value;
+  if (f >= keys.at(-1).frame) return keys.at(-1).value;
+  const i = keys.findIndex((k) => k.frame >= f), from = keys[i - 1], to = keys[i], t = ease((f - from.frame) / (to.frame - from.frame), to.easing ?? "linear");
+  return typeof from.value === "string" || typeof to.value === "string" ? mixColors(String(from.value), String(to.value), t) : from.value + (to.value - from.value) * t;
+}
+
+// packages/timeline/src/index.ts
+function splitPresetAnimations(preset, duration, fontSize) {
+  const d = duration, fade = Math.max(1, Math.round(d * 0.6)), em = fontSize;
+  const appear = { property: "opacity", keyframes: [{ frame: 0, value: 0 }, { frame: fade, value: 1 }] };
+  switch (preset) {
+    case "fade":
+      return [{ property: "opacity", keyframes: [{ frame: 0, value: 0 }, { frame: d, value: 1, easing: "glide" }] }];
+    case "pop":
+      return [{ property: "opacity", keyframes: [{ frame: 0, value: 0 }, { frame: Math.max(1, Math.round(d * 0.35)), value: 1 }] }, { property: "scale", keyframes: [{ frame: 0, value: 0.6 }, { frame: d, value: 1, easing: "pop" }] }];
+    case "blur":
+      return [appear, { property: "blur", keyframes: [{ frame: 0, value: 0.25 * em }, { frame: d, value: 0, easing: "land" }] }, { property: "scale", keyframes: [{ frame: 0, value: 1.08 }, { frame: d, value: 1, easing: "land" }] }];
+    case "slide":
+      return [appear, { property: "x", keyframes: [{ frame: 0, value: 0.6 * em }, { frame: d, value: 0, easing: "land" }] }];
+    case "drop":
+      return [appear, { property: "y", keyframes: [{ frame: 0, value: -0.5 * em }, { frame: d, value: 0, easing: "land" }] }];
+    case "typewriter":
+      return [{ property: "opacity", keyframes: [{ frame: 0, value: 0 }, { frame: 1, value: 1, easing: "hold" }] }];
+    default:
+      return [appear, { property: "y", keyframes: [{ frame: 0, value: 0.45 * em }, { frame: d, value: 0, easing: "land" }] }];
+  }
+}
+function splitCount(layer) {
+  const text = layer.spans?.length ? layer.spans.map((s) => s.text).join("") : String(layer.content ?? "");
+  return Math.max(1, layer.split?.by === "letters" ? Array.from(text.replace(/\s/g, "")).length : text.split(/\s+/).filter(Boolean).length);
+}
+function splitUnits(layer, own) {
+  const split = layer.split, animations = split.animations?.length ? split.animations : splitPresetAnimations(split.preset, split.duration, layer.fontSize);
+  return Array.from({ length: splitCount(layer) }, (_, step) => Object.fromEntries(animations.map((a) => [a.property, evaluateAnimation(a, own - step * split.stagger)])));
+}
+var frameToSeconds = (frame, fps) => frame / fps;
+var secondsToFrame = (seconds3, fps) => Math.round(seconds3 * fps);
+function evaluateLayers(layers, frame) {
+  return layers.filter((layer) => layer.visible && frame >= layer.startFrame && (layer.endFrame === void 0 || frame < layer.endFrame)).map((layer) => {
+    const own = frame - layer.startFrame;
+    const evaluated = Object.fromEntries(layer.animations.filter((a) => a.property !== "d").map((a) => [a.property, evaluateAnimation(a, own)]));
+    const shape = layer.animations.find((a) => a.property === "d");
+    return { ...layer, localFrame: frame, evaluated, ...shape ? { morph: animationSegment(shape, own) } : {}, ...layer.type === "group" ? { children: evaluateLayers(layer.children, own) } : {}, ...layer.type === "text" && layer.split ? { units: splitUnits(layer, own) } : {} };
+  }).sort((a, b) => a.zIndex - b.zIndex);
+}
+function transitionState(effects, width, height) {
+  let x = 0, y = 0, opacity = 1, scale = 1, clip = { x: 0, y: 0, width, height };
+  let clipped = false, clipPath, blur = 0, overlay;
+  for (const { transition, progress } of effects) {
+    const p = ease(progress, transition.easing), dir = transition.direction;
+    if (transition.type === "fade") opacity *= p;
+    else if (transition.type === "zoom") {
+      opacity *= p;
+      scale *= 0.85 + 0.15 * p;
+    } else if (transition.type === "iris") {
+      const cx = transition.x ?? width / 2, cy = transition.y ?? height / 2, r = Math.max(0.01, p * Math.hypot(Math.max(cx, width - cx), Math.max(cy, height - cy)));
+      clipPath = `M${cx - r} ${cy}A${r} ${r} 0 1 0 ${cx + r} ${cy}A${r} ${r} 0 1 0 ${cx - r} ${cy}Z`;
+    } else if (transition.type === "dip") {
+      if (progress < 0.5) opacity = 0;
+      overlay = { color: transition.color, opacity: 1 - Math.abs(2 * progress - 1) };
+    } else if (transition.type === "blur") {
+      opacity *= Math.min(1, p * 1.5);
+      blur = Math.max(blur, (1 - p) * 0.02 * Math.max(width, height));
+    } else if (transition.type === "slide" || transition.type === "push") {
+      if (dir === "left") x -= (1 - p) * width;
+      else if (dir === "right") x += (1 - p) * width;
+      else if (dir === "top") y -= (1 - p) * height;
+      else y += (1 - p) * height;
+    } else {
+      clipped = true;
+      const visible = dir === "left" ? { x: 0, y: 0, width: p * width, height } : dir === "right" ? { x: (1 - p) * width, y: 0, width: p * width, height } : dir === "top" ? { x: 0, y: 0, width, height: p * height } : { x: 0, y: (1 - p) * height, width, height: p * height };
+      const left = Math.max(clip.x, visible.x), top = Math.max(clip.y, visible.y);
+      clip = { x: left, y: top, width: Math.max(0, Math.min(clip.x + clip.width, visible.x + visible.width) - left), height: Math.max(0, Math.min(clip.y + clip.height, visible.y + visible.height) - top) };
+    }
+  }
+  return { x, y, opacity, scale, clip: clipped ? clip : void 0, clipPath, blur, overlay };
+}
+var wobble = (t, phase) => (Math.sin(t * 1.31 + phase) + 0.6 * Math.sin(t * 2.93 + phase * 2.1) + 0.3 * Math.sin(t * 5.37 + phase * 3.7)) / 1.9;
+function cameraState(camera, frame, width, height) {
+  const value = (name2, fallback) => {
+    const a = camera.animations.find((x) => x.property === name2);
+    return a ? Number(evaluateAnimation(a, frame)) : fallback;
+  };
+  const shake = value("shake", camera.shake);
+  return { x: value("x", camera.x ?? width / 2) + shake * wobble(frame * 0.9, 0.3), y: value("y", camera.y ?? height / 2) + shake * wobble(frame * 0.9, 2.1), zoom: value("zoom", camera.zoom), rotation: value("rotation", camera.rotation) + shake * 0.04 * wobble(frame * 0.7, 4.2) };
+}
+function evaluateFrame(composition, frame) {
+  if (!Number.isFinite(frame) || frame < 0 || frame >= composition.durationFrames) return [];
+  const { width, height } = composition;
+  const pushes = composition.scenes.map((scene, index) => ({ scene, index })).filter(({ scene }) => scene.transitionIn?.type === "push" && frame >= scene.startFrame && frame < scene.startFrame + scene.transitionIn.durationFrames).map(({ scene, index }) => {
+    const t = scene.transitionIn, p = ease(Math.min(1, (frame - scene.startFrame) / t.durationFrames), t.easing), dir = t.direction;
+    return { index, dx: dir === "left" ? p * width : dir === "right" ? -p * width : 0, dy: dir === "top" ? p * height : dir === "bottom" ? -p * height : 0 };
+  });
+  return composition.scenes.flatMap((scene, index) => {
+    if (frame < scene.startFrame || frame >= scene.startFrame + scene.durationFrames) return [];
+    const localFrame = frame - scene.startFrame;
+    let layers = evaluateLayers(scene.layers, localFrame);
+    if (scene.camera) {
+      const cam = cameraState(scene.camera, localFrame, width, height), moving = layers.filter((l) => !l.fixed), fixed = layers.filter((l) => l.fixed);
+      layers = [{ id: `camera:${scene.id}`, type: "group", startFrame: 0, x: width / 2 - cam.x, y: height / 2 - cam.y, originX: cam.x, originY: cam.y, scale: cam.zoom, rotation: -cam.rotation, opacity: 1, zIndex: 0, visible: true, fixed: false, animations: [], children: moving, evaluated: {}, localFrame }, ...fixed];
+    }
+    const effects = [scene.transitionIn && { transition: scene.transitionIn, progress: Math.min(1, localFrame / scene.transitionIn.durationFrames) }, scene.transitionOut && { transition: scene.transitionOut, progress: Math.min(1, (scene.durationFrames - localFrame) / scene.transitionOut.durationFrames) }].filter((e) => !!e && e.progress < 1);
+    const pushed = pushes.filter((p) => p.index > index).reduce((o, p) => ({ dx: o.dx + p.dx, dy: o.dy + p.dy }), { dx: 0, dy: 0 });
+    if (!effects.length && !pushed.dx && !pushed.dy) return layers;
+    const state = transitionState(effects, width, height);
+    state.x += pushed.dx;
+    state.y += pushed.dy;
+    const overlay = state.overlay && state.overlay.opacity > 0 ? [{ id: `dip:${scene.id}`, type: "rect", startFrame: 0, x: 0, y: 0, width, height, fill: state.overlay.color, opacity: state.overlay.opacity, scale: 1, rotation: 0, originX: 0, originY: 0, zIndex: 0, visible: true, animations: [], evaluated: {}, localFrame }] : [];
+    return [{ id: `scene:${scene.id}`, type: "group", startFrame: 0, x: state.x, y: state.y, opacity: state.opacity, scale: state.scale, rotation: 0, originX: width / 2, originY: height / 2, zIndex: 0, visible: true, animations: [], children: layers, clip: state.clip, clipPath: state.clipPath, blur: state.blur, evaluated: {}, localFrame }, ...overlay];
+  });
+}
+function videoFrameIndex(layer, ownFrame, frameCount) {
+  if (frameCount < 1) throw new Error("Video has no frames");
+  const frame = Math.max(0, Math.floor(layer.trimStart + ownFrame * layer.playbackRate + 1e-9));
+  return layer.loop ? frame % frameCount : Math.min(frame, frameCount - 1);
+}
+function layerWindows(composition, include) {
+  const out = [];
+  const walk = (layers, offset, limit) => {
+    for (const layer of layers) {
+      if (!layer.visible) continue;
+      const start = offset + layer.startFrame, end = Math.min(limit, layer.endFrame === void 0 ? Infinity : offset + layer.endFrame);
+      if (end <= start) continue;
+      if (layer.type === "group") walk(layer.children, start, end);
+      else if (include(layer)) out.push({ layer, startFrame: start, endFrame: end });
+    }
+  };
+  for (const scene of composition.scenes) walk(scene.layers, scene.startFrame, Math.min(scene.startFrame + scene.durationFrames, composition.durationFrames));
+  return out;
+}
+var audioWindows = (composition) => layerWindows(composition, (layer) => layer.type === "audio" ? layer.volume > 0 : layer.type === "video" && !layer.muted && layer.volume > 0);
+function soundIntervals(composition, media = {}) {
+  const fps = composition.fps;
+  return audioWindows(composition).map(({ layer, startFrame, endFrame }) => {
+    const from = startFrame / fps, to = endFrame / fps, info = media[layer.src];
+    if (!info) return { layer, intervals: [[from, to]] };
+    const trim = (layer.trimStart ?? 0) / fps, rate = layer.playbackRate ?? 1;
+    const intervals = info.segments.map((s) => [from + (s.start - trim) / rate, from + (s.end - trim) / rate]).map(([a, b]) => [Math.max(a, from), Math.min(b, to)]).filter(([a, b]) => b > a);
+    return { layer, intervals };
+  });
+}
+function volumeEnvelope(options) {
+  const { layer, fps, start, duration, duck } = options;
+  const animation2 = (layer.animations ?? []).find((a) => a.property === "volume");
+  const triggers = duck ? options.others.filter((o) => o.layer !== layer && (!duck.by || duck.by.includes(o.layer.id))).flatMap((o) => o.intervals).map(([a, b]) => [a - start, b - start]).filter(([a, b]) => b > 0 && a < duration).sort((x, y) => x[0] - y[0]) : [];
+  if (!animation2 && !triggers.length) return void 0;
+  const attack = Math.max(1e-3, (duck?.attackFrames ?? 0) / fps), release = Math.max(1e-3, (duck?.releaseFrames ?? 0) / fps);
+  const merged = [];
+  for (const [a, b] of triggers) {
+    const last = merged.at(-1);
+    if (last && a - last[1] < attack + release) last[1] = Math.max(last[1], b);
+    else merged.push([a, b]);
+  }
+  const duckAt = (t) => merged.reduce((f, [a, b]) => Math.min(f, t >= a && t <= b ? duck.amount : t < a && t > a - attack ? 1 - (1 - duck.amount) * (t - (a - attack)) / attack : t > b && t < b + release ? duck.amount + (1 - duck.amount) * (t - b) / release : 1), 1);
+  const volumeAt = (t) => animation2 ? Number(evaluateAnimation(animation2, t * fps)) : layer.volume ?? 1;
+  const times = /* @__PURE__ */ new Set([0, duration]);
+  if (animation2) for (let k = 0; k <= Math.ceil(duration * fps); k++) times.add(Math.min(duration, k / fps));
+  for (const [a, b] of merged) for (const t of [a - attack, a, b, b + release]) if (t > 0 && t < duration) times.add(t);
+  const points = [...times].sort((a, b) => a - b).map((t) => [t, Math.max(0, volumeAt(t) * duckAt(t))]);
+  return points.filter((p, i) => {
+    const prev = points[i - 1], next = points[i + 1];
+    if (!prev || !next) return true;
+    const expected = prev[1] + (next[1] - prev[1]) * (p[0] - prev[0]) / (next[0] - prev[0]);
+    return Math.abs(expected - p[1]) > 1e-4;
+  });
+}
+
+// packages/assets/src/index.ts
+import { readFile } from "node:fs/promises";
+import { extname, isAbsolute, resolve } from "node:path";
+
+// packages/assets/src/cache.ts
+import { readdir, rm, stat, utimes } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var cacheKinds = ["media", "video", "sfx"];
+var cacheRoot = () => process.env.OVE_CACHE_DIR ?? join(tmpdir(), "ove-video-cache");
+var cacheDir = (kind) => join(cacheRoot(), kind);
+var touchCacheEntry = (path) => {
+  const now = /* @__PURE__ */ new Date();
+  return utimes(path, now, now).catch(() => {
+  });
+};
+var sizeOf = async (path) => {
+  const info = await stat(path).catch(() => void 0);
+  if (!info) return 0;
+  if (!info.isDirectory()) return info.size;
+  let total = 0;
+  for (const name2 of await readdir(path).catch(() => [])) total += await sizeOf(join(path, name2));
+  return total;
+};
+var legacyEntry = /^[0-9a-f]{32}(\.partial-[0-9a-f-]{36})?$/;
+var entries = async (kind) => {
+  const dir = kind === "other" ? cacheRoot() : cacheDir(kind);
+  const names = (await readdir(dir).catch(() => [])).filter((name2) => kind !== "other" || legacyEntry.test(name2));
+  return Promise.all(names.map(async (name2) => {
+    const path = join(dir, name2), info = await stat(path).catch(() => void 0);
+    return { path, used: info?.mtimeMs ?? 0 };
+  }));
+};
+async function cacheUsage() {
+  const kinds = await Promise.all([...cacheKinds, "other"].map(async (kind) => {
+    const list = await entries(kind);
+    let bytes = 0;
+    for (const e of list) bytes += await sizeOf(e.path);
+    return { kind, entries: list.length, bytes };
+  }));
+  return { root: cacheRoot(), kinds, bytes: kinds.reduce((n, k) => n + k.bytes, 0) };
+}
+async function cleanCache(options = {}) {
+  const cutoff = options.olderThanMs === void 0 ? Infinity : Date.now() - options.olderThanMs;
+  let removed = 0, bytes = 0;
+  for (const kind of options.kinds ?? [...cacheKinds, "other"]) for (const e of await entries(kind)) if (e.used < cutoff) {
+    bytes += await sizeOf(e.path);
+    await rm(e.path, { recursive: true, force: true });
+    removed++;
+  }
+  return { entries: removed, bytes };
+}
+
+// packages/assets/src/index.ts
+var mimeTypes = { ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".webp": "image/webp", ".gif": "image/gif", ".svg": "image/svg+xml", ".woff2": "font/woff2", ".woff": "font/woff", ".ttf": "font/ttf", ".otf": "font/otf" };
+function validateAssetPath(src) {
+  if (!src || src.includes("\0")) throw new Error("Invalid asset source");
+}
+var isUrl = (src) => /^(https?|data|blob):/i.test(src);
+function resolveAssetSource(composition, src, baseDir) {
+  validateAssetPath(src);
+  const target = composition.assets.find((a) => a.id === src)?.src ?? src;
+  validateAssetPath(target);
+  return isUrl(target) || isAbsolute(target) ? target : resolve(baseDir, target);
+}
+async function toDataUrl(source) {
+  if (isUrl(source)) return source;
+  const mime = mimeTypes[extname(source).toLowerCase()];
+  if (!mime) throw new Error(`Unsupported file type for an image or font: ${source}`);
+  return `data:${mime};base64,${(await readFile(source)).toString("base64")}`;
+}
+
+// packages/ffmpeg/src/index.ts
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { join as join2 } from "node:path";
+var x264Presets = ["ultrafast", "superfast", "veryfast", "faster", "fast", "medium", "slow", "slower", "veryslow"];
+var defaultPreset = "veryfast";
+var ffmpegPath = () => process.env.OVE_FFMPEG_PATH || "ffmpeg";
+var ffprobePath = () => process.env.OVE_FFPROBE_PATH || "ffprobe";
+var notFound = (tool, env) => new Error(`${tool} was not found. Install FFmpeg (it includes ${tool}) and put it on PATH, or set ${env} to the executable.`);
+var num2 = (n) => {
+  const text = n.toFixed(5).replace(/\.?0+$/, "");
+  return text === "" || text === "-0" ? "0" : text;
+};
+function envelopeExpression(points) {
+  if (points.length === 1) return num2(points[0][1]);
+  const segment = (i) => {
+    const [t0, v0] = points[i], [t1, v1] = points[i + 1];
+    return t1 <= t0 ? num2(v1) : `${num2(v0)}+(${num2(v1 - v0)})*(t-${num2(t0)})/${num2(t1 - t0)}`;
+  };
+  const tree = (lo, hi) => {
+    if (lo === hi) return `(${segment(lo)})`;
+    const mid = Math.floor((lo + hi + 1) / 2);
+    return `if(lt(t,${num2(points[mid][0])}),${tree(lo, mid - 1)},${tree(mid, hi)})`;
+  };
+  const [lastT, lastV] = points[points.length - 1];
+  return `if(gte(t,${num2(lastT)}),${num2(lastV)},${tree(0, points.length - 2)})`;
+}
+var seconds = (n) => n.toFixed(6);
+var tempo = (rate) => {
+  const filters = [];
+  let remaining = rate;
+  while (remaining < 0.5) {
+    filters.push("atempo=0.5");
+    remaining /= 0.5;
+  }
+  if (remaining !== 1) filters.push(`atempo=${remaining}`);
+  return filters;
+};
+function audioMixArgs(mix, audioCodec = ["-c:a", "aac", "-b:a", "192k"]) {
+  if (!mix || mix.clips.length === 0) return [];
+  const inputs = [], chains = [];
+  mix.clips.forEach((clip, i) => {
+    inputs.push(...clip.loop ? ["-stream_loop", "-1"] : [], "-i", clip.source);
+    const fadeIn = Math.min(clip.fadeIn ?? 0, clip.duration), fadeOut = Math.min(clip.fadeOut ?? 0, clip.duration);
+    const filters = [`atrim=start=${seconds(clip.trim ?? 0)}`, "asetpts=PTS-STARTPTS", ...tempo(clip.rate ?? 1), `atrim=duration=${seconds(clip.duration)}`, "asetpts=PTS-STARTPTS", "aformat=sample_rates=48000:channel_layouts=stereo", clip.envelope?.length ? `volume='${envelopeExpression(clip.envelope)}':eval=frame` : `volume=${clip.volume ?? 1}`, ...fadeIn > 0 ? [`afade=t=in:d=${seconds(fadeIn)}`] : [], ...fadeOut > 0 ? [`afade=t=out:st=${seconds(clip.duration - fadeOut)}:d=${seconds(fadeOut)}`] : [], `adelay=delays=${Math.round(clip.start * 48e3)}S:all=1`];
+    chains.push(`[${i + 1}:a]${filters.join(",")}[a${i}]`);
+  });
+  const labels = mix.clips.map((_, i) => `[a${i}]`).join("");
+  const mixed = mix.clips.length === 1 ? `${labels}apad` : `${labels}amix=inputs=${mix.clips.length}:duration=longest:normalize=0,apad`, master = mix.gainDb === void 0 ? "" : `,volume=${mix.gainDb.toFixed(2)}dB,alimiter=limit=0.84:level=false:attack=5:release=50`;
+  return [...inputs, "-filter_complex", `${chains.join(";")};${mixed}${master},atrim=start=${seconds(mix.offsetSeconds ?? 0)}:duration=${seconds(mix.durationSeconds)},asetpts=PTS-STARTPTS[aout]`, "-map", "0:v", "-map", "[aout]", ...audioCodec];
+}
+var tone = (expr, seconds3) => ["-f", "lavfi", "-i", `aevalsrc=${expr}:s=48000:d=${seconds3}`];
+var sfxRecipes = {
+  click: tone("0.8*sin(2*PI*2400*t)*exp(-t*150)+0.35*sin(2*PI*5200*t)*exp(-t*300)", 0.06),
+  tick: tone("0.55*sin(2*PI*3800*t)*exp(-t*260)", 0.04),
+  pop: tone("0.9*sin(2*PI*(1000*t-2200*t*t))*exp(-t*28)", 0.18),
+  thump: tone("0.9*sin(2*PI*(110*t-80*t*t))*exp(-t*9)+0.3*sin(2*PI*55*t)*exp(-t*6)", 0.6),
+  ding: tone("0.5*sin(2*PI*1318*t)*exp(-t*3)+0.25*sin(2*PI*3640*t)*exp(-t*5)+0.12*sin(2*PI*7110*t)*exp(-t*8)", 1.8),
+  riser: tone("(t/1.6)*(t/1.6)*(0.6*sin(2*PI*(180*t+380*t*t))+0.25*sin(2*PI*(360*t+760*t*t)))", 1.6),
+  whoosh: ["-f", "lavfi", "-i", "anoisesrc=d=0.7:c=pink:a=0.9:r=48000:seed=11", "-af", "highpass=f=300,lowpass=f=3500,volume='sin(PI*t/0.7)*sin(PI*t/0.7)*sin(PI*t/0.7)':eval=frame,volume=3"]
+};
+var sfxArgs = (name2, output) => {
+  const recipe = sfxRecipes[name2];
+  if (!recipe) throw new Error(`Unknown sound effect "${name2}"`);
+  return ["-v", "error", "-y", ...recipe, "-ac", "2", "-ar", "48000", "-c:a", "pcm_s16le", output];
+};
+function formatArgs(fps, options) {
+  const preset = options.preset ?? defaultPreset, rate = ["-r", String(fps)];
+  const x26x = (defaultCrf) => options.bitrate ? ["-b:v", options.bitrate, "-maxrate", options.bitrate, "-bufsize", options.bitrate] : ["-crf", String(options.crf ?? defaultCrf)];
+  switch (options.format ?? "mp4") {
+    case "webm":
+      return { video: ["-c:v", "libvpx-vp9", "-b:v", options.bitrate ?? "0", "-crf", String(options.crf ?? 32), "-row-mt", "1", "-deadline", "good", "-cpu-used", "4", "-pix_fmt", options.transparent ? "yuva420p" : "yuv420p", ...rate], audio: ["-c:a", "libopus", "-b:a", options.audioBitrate ?? "160k"] };
+    case "mov":
+      return { video: ["-c:v", "prores_ks", "-profile:v", options.transparent ? "4" : "3", "-pix_fmt", options.transparent ? "yuva444p10le" : "yuv422p10le", "-vendor", "apl0", ...rate], audio: ["-c:a", "pcm_s16le"] };
+    case "gif":
+      return { video: ["-vf", "split[a][b];[a]palettegen=stats_mode=full[p];[b][p]paletteuse=dither=sierra2_4a", "-loop", "0", ...rate], audio: void 0 };
+    default:
+      return { video: options.codec === "h265" ? ["-c:v", "libx265", "-preset", preset, ...x26x(24), "-pix_fmt", "yuv420p", "-tag:v", "hvc1", "-x265-params", "log-level=error:aq-mode=3", "-movflags", "+faststart", ...rate] : ["-c:v", "libx264", "-preset", preset, ...x26x(20), "-x264-params", "aq-mode=3", "-pix_fmt", "yuv420p", "-movflags", "+faststart", ...rate], audio: ["-c:a", "aac", "-b:a", options.audioBitrate ?? "192k"] };
+  }
+}
+function run(args, stdin) {
+  const child = spawn(ffmpegPath(), args, { stdio: [stdin, "ignore", "pipe"] });
+  let error = "";
+  child.stderr.on("data", (d) => error += d);
+  const done = new Promise((resolve4, reject) => {
+    child.on("error", (e) => reject(e.code === "ENOENT" ? notFound("ffmpeg", "OVE_FFMPEG_PATH") : e));
+    child.on("close", (code) => code === 0 ? resolve4() : reject(new Error(`FFmpeg exited ${code}: ${error.slice(-1e3)}`)));
+  });
+  return { child, done };
+}
+var encodeArgs = (fps, audio, options) => {
+  const { video, audio: audioCodec } = formatArgs(fps, options);
+  return [...audioCodec ? audioMixArgs(audio, audioCodec) : [], ...video];
+};
+function createEncoder(fps, output, audio, options = {}) {
+  const { child, done } = run(["-y", "-f", "image2pipe", "-c:v", "png", "-framerate", String(fps), "-i", "-", ...encodeArgs(fps, audio, options), output], "pipe");
+  const stdin = child.stdin;
+  stdin.on("error", () => {
+  });
+  done.catch(() => {
+  });
+  return { async write(frame) {
+    if (!stdin.write(frame)) await Promise.race([once(stdin, "drain"), done.then(() => {
+      throw new Error("FFmpeg exited before all frames were written");
+    })]);
+  }, finish() {
+    stdin.end();
+    return done;
+  }, abort() {
+    child.kill();
+  } };
+}
+function concatSegments(segments, listFile, output, audio, options = {}) {
+  const { audio: audioCodec } = formatArgs(30, { format: options.format ?? "mp4", audioBitrate: options.audioBitrate });
+  const list = segments.map((s) => `file '${s.replace(/\\/g, "/").replace(/'/g, "'\\''")}'`).join("\n");
+  return import("node:fs/promises").then((fs) => fs.writeFile(listFile, list)).then(() => run(["-y", "-f", "concat", "-safe", "0", "-i", listFile, ...audioCodec ? audioMixArgs(audio, audioCodec) : [], ...audio && audioCodec ? [] : ["-map", "0:v"], "-c:v", "copy", ...options.format === "mp4" || options.format === void 0 ? ["-movflags", "+faststart"] : [], output], "ignore").done);
+}
+function extractFrames(source, outDir, options) {
+  const { fps, maxWidth, maxHeight, durationSeconds, startSeconds } = options;
+  return run(["-v", "error", "-y", ...startSeconds ? ["-ss", String(startSeconds)] : [], ...durationSeconds === void 0 ? [] : ["-t", String(durationSeconds)], "-i", source, "-an", "-vf", `fps=${fps},scale=w='min(iw,${maxWidth})':h='min(ih,${maxHeight})':force_original_aspect_ratio=decrease`, "-q:v", "2", join2(outDir, "%06d.jpg")], "ignore").done;
+}
+var requiredEncoders = { mp4: ["libx264", "aac"], "mp4 (h265)": ["libx265"], webm: ["libvpx-vp9", "libopus"], mov: ["prores_ks", "pcm_s16le"], gif: ["gif"], "video layers": ["mjpeg"] };
+function checkFfmpeg() {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(ffmpegPath(), ["-hide_banner", "-encoders"]);
+    let out = "";
+    child.stdout.on("data", (d) => out += d);
+    child.on("error", (e) => reject(e.code === "ENOENT" ? notFound("ffmpeg", "OVE_FFMPEG_PATH") : e));
+    child.on("close", () => {
+      const have = new Set([...out.matchAll(/^\s*[VAS][.A-Z]{5}\s+(\S+)/gm)].map((m) => m[1]));
+      const missing = Object.fromEntries(Object.entries(requiredEncoders).map(([use, names]) => [use, names.filter((n) => !have.has(n))]).filter(([, names]) => names.length));
+      const version = spawn(ffmpegPath(), ["-version"]);
+      let v = "";
+      version.stdout.on("data", (d) => v += d);
+      version.on("close", () => resolve4({ version: v.split("\n")[0]?.trim() ?? "unknown", missing }));
+      version.on("error", reject);
+    });
+  });
+}
+function hasAudioStream(path) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(ffprobePath(), ["-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", path]);
+    let out = "";
+    child.stdout.on("data", (d) => out += d);
+    child.on("error", (e) => reject(e.code === "ENOENT" ? notFound("ffprobe", "OVE_FFPROBE_PATH") : e));
+    child.on("close", (c) => c === 0 ? resolve4(out.trim().length > 0) : reject(new Error(`ffprobe could not read ${path}`)));
+  });
+}
+function probe(path) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn(ffprobePath(), ["-v", "error", "-show_entries", "format=duration", "-of", "default=noprint_wrappers=1:nokey=1", path]);
+    let out = "";
+    child.stdout.on("data", (d) => out += d);
+    child.on("error", (e) => reject(e.code === "ENOENT" ? notFound("ffprobe", "OVE_FFPROBE_PATH") : e));
+    child.on("close", (c) => c === 0 ? resolve4(out.trim()) : reject(new Error("ffprobe failed")));
+  });
+}
+
+// packages/core/src/media.ts
+var run2 = (cmd, args) => new Promise((ok, fail) => {
+  const child = spawn2(cmd, args);
+  let out = "";
+  child.stdout.on("data", (d) => out += d);
+  child.stderr.on("data", (d) => out += d);
+  child.on("error", fail);
+  child.on("close", (code) => code === 0 ? ok(out) : fail(new Error(`${cmd} failed on ${args[args.indexOf("-i") + 1] ?? args.at(-1)}`)));
+});
+var mediaCache = () => cacheDir("media");
+async function measureSource(source) {
+  const version = isUrl(source) ? "" : await stat2(source).then((s) => `${s.size}:${s.mtimeMs}`, () => {
+    throw new Error(`Media not found: ${source}`);
+  });
+  const key = createHash("sha256").update(`${source}|${version}|v1`).digest("hex").slice(0, 32), file = join3(mediaCache(), `${key}.json`);
+  const cached2 = await readFile2(file, "utf8").then(JSON.parse, () => void 0);
+  if (cached2) {
+    void touchCacheEntry(file);
+    return cached2;
+  }
+  const duration = Number((await run2(ffprobePath(), ["-v", "error", "-show_entries", "format=duration", "-of", "csv=p=0", source])).trim()) || 0;
+  const hasAudio = (await run2(ffprobePath(), ["-v", "error", "-select_streams", "a", "-show_entries", "stream=index", "-of", "csv=p=0", source])).trim().length > 0;
+  let sounds = [];
+  if (hasAudio) {
+    const log = await run2(ffmpegPath(), ["-hide_banner", "-nostats", "-i", source, "-vn", "-af", "silencedetect=noise=-45dB:d=0.25", "-f", "null", "-"]);
+    let soundStart = 0, silent = false;
+    for (const m of log.matchAll(/silence_(start|end): ([\d.]+)/g)) {
+      const t = Number(m[2]);
+      if (m[1] === "start") {
+        sounds.push([soundStart, t]);
+        silent = true;
+      } else {
+        soundStart = t;
+        silent = false;
+      }
+    }
+    if (!silent) sounds.push([soundStart, duration]);
+    sounds = sounds.filter(([a, b]) => b - a > 0.05);
+  }
+  const measured = { duration, sounds };
+  await mkdir(mediaCache(), { recursive: true });
+  await writeFile(file, JSON.stringify(measured));
+  return measured;
+}
+async function measureMedia(raw, baseDir, fps = typeof raw?.fps === "number" ? raw.fps : 30) {
+  if (!/\bmedia\s*[.[]/.test(JSON.stringify(raw ?? {}))) return {};
+  const assets = (Array.isArray(raw?.assets) ? raw.assets : []).filter((a) => (a?.type === "audio" || a?.type === "video") && typeof a.src === "string" && !a.src.includes("{{"));
+  const stub = { assets };
+  return Object.fromEntries(await Promise.all(assets.map(async (asset) => {
+    const m = await measureSource(resolveAssetSource(stub, asset.id, baseDir));
+    const segments = m.sounds.map(([start, end]) => ({ start, end, startFrame: Math.floor(start * fps), endFrame: Math.ceil(end * fps) }));
+    const soundEnd = m.sounds.at(-1)?.[1] ?? 0;
+    return [asset.id, { duration: m.duration, frames: Math.ceil(m.duration * fps), segments, soundEnd, soundEndFrames: Math.ceil(soundEnd * fps) }];
+  })));
+}
+async function attachCaptions(composition, baseDir) {
+  const files = /* @__PURE__ */ new Map();
+  const walk = async (layers) => {
+    for (const layer of layers) {
+      if (layer.type === "group") await walk(layer.children ?? []);
+      if (layer.type === "captions" && !layer.cues) {
+        const source = resolveAssetSource(composition, layer.src, baseDir);
+        if (!files.has(source)) files.set(source, (isUrl(source) ? fetch(source).then((r) => {
+          if (!r.ok) throw new Error(`Captions not found: ${source}`);
+          return r.text();
+        }) : readFile2(source, "utf8").catch(() => {
+          throw new Error(`Captions not found: ${source}`);
+        })).then((text) => parseCaptions(text, source, Infinity)));
+        layer.cues = await files.get(source);
+      }
+    }
+  };
+  for (const scene of composition.scenes) await walk(scene.layers);
+  return composition;
+}
+function captionTrack(composition) {
+  const fps = composition.fps;
+  return layerWindows(composition, (layer) => layer.type === "captions").flatMap(({ layer, startFrame, endFrame }) => {
+    const shift = startFrame / fps + (layer.offset ?? 0), end = endFrame / fps;
+    return captionLines(layer.dropFillers ? dropFillerWords(layer.cues ?? []) : layer.cues ?? [], layer.maxWords).map((cue) => ({ text: cue.text, start: cue.start + shift, end: Math.min(cue.end + shift, end) })).filter((cue) => cue.end > cue.start);
+  }).sort((a, b) => a.start - b.start);
+}
+async function prepareComposition(raw, values = {}, baseDir = process.cwd()) {
+  const composition = loadComposition(raw, values, { media: await measureMedia(raw, baseDir) });
+  return attachCaptions(composition, baseDir);
+}
+
+// packages/renderer/src/index.ts
+import { chromium } from "playwright";
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { availableParallelism } from "node:os";
+
+// packages/graphics/src/index.ts
+var resolveOrigin = (value, layer, axis) => {
+  if (value !== "center") return typeof value === "number" ? value : 0;
+  if (layer.type === "circle") return 0;
+  if (layer.type === "text") return axis === "y" ? layer.fontSize * layer.lineHeight / 2 : layer.textAlign === "center" ? 0 : (layer.textAlign === "right" ? -1 : 1) * (layer.maxWidth ?? 0) / 2;
+  return ((axis === "x" ? layer.width : layer.height) ?? 0) / 2;
+};
+var finalLayer = (layer) => {
+  const merged = { ...layer, ...layer.evaluated };
+  return { ...merged, originX: resolveOrigin(merged.originX, merged, "x"), originY: resolveOrigin(merged.originY, merged, "y") };
+};
+var toDrawOperations = (layers) => layers.filter((layer) => layer.type !== "audio").map(finalLayer).map((layer) => layer.type === "group" ? { kind: "group", layer, children: toDrawOperations(layer.children ?? []) } : { kind: layer.type, layer });
+var flattenLayers = (layers) => layers.flatMap((l) => l.type === "group" ? [l, ...flattenLayers(l.children ?? [])] : [l]);
+var flattenOperations = (operations) => operations.flatMap((op) => op.kind === "group" ? [op, ...flattenOperations(op.children ?? [])] : [op]);
+var htmlReferences = (layer) => {
+  const text = `${layer.html ?? ""}
+${layer.css ?? ""}`, refs = [...text.matchAll(/(?<![\w:-])src\s*=\s*(["'])([^"']+)\1/gi)].map((m) => m[2]).concat([...text.matchAll(/url\(\s*(["']?)([^"')]+)\1\s*\)/gi)].map((m) => m[2].trim()));
+  return refs.filter((ref) => !/^(data:|#|blob:)/i.test(ref));
+};
+var collectCodeSources = (layers) => [...new Set(flattenLayers(layers).filter((l) => (l.type === "code" || l.type === "react") && typeof l.src === "string").map((l) => l.src))];
+var hasCodeLayers = (layers) => flattenLayers(layers).some((l) => l.type === "code" || l.type === "react");
+var hasReactLayers = (layers) => flattenLayers(layers).some((l) => l.type === "react");
+var collectLottieSources = (layers) => [...new Set(flattenLayers(layers).filter((l) => l.type === "lottie").map((l) => l.src))];
+var collectImageSources = (layers) => [...new Set(flattenLayers(layers).flatMap((l) => l.type === "image" ? [l.src] : l.type === "html" ? htmlReferences(l) : []))];
+var genericFamilies = /* @__PURE__ */ new Set(["serif", "sans-serif", "monospace", "cursive", "fantasy", "system-ui", "ui-serif", "ui-sans-serif", "ui-monospace", "ui-rounded", "emoji", "math", "fangsong"]);
+var builtinFontFaces = [
+  { family: "Inter", file: "inter-latin-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD" },
+  { family: "Inter", file: "inter-latin-ext-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF" },
+  { family: "Inter", file: "inter-cyrillic-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116" },
+  { family: "Inter", file: "inter-cyrillic-ext-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0460-052F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F" },
+  { family: "Inter", file: "inter-greek-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF" },
+  { family: "Inter", file: "inter-greek-ext-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+1F00-1FFF" },
+  { family: "Inter", file: "inter-vietnamese-opsz-normal.woff2", weight: "100 900", style: "normal", unicodeRange: "U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB" },
+  { family: "Inter", file: "inter-latin-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD" },
+  { family: "Inter", file: "inter-latin-ext-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF" },
+  { family: "Inter", file: "inter-cyrillic-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0301,U+0400-045F,U+0490-0491,U+04B0-04B1,U+2116" },
+  { family: "Inter", file: "inter-cyrillic-ext-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0460-052F,U+1C80-1C8A,U+20B4,U+2DE0-2DFF,U+A640-A69F,U+FE2E-FE2F" },
+  { family: "Inter", file: "inter-greek-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0370-0377,U+037A-037F,U+0384-038A,U+038C,U+038E-03A1,U+03A3-03FF" },
+  { family: "Inter", file: "inter-greek-ext-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+1F00-1FFF" },
+  { family: "Inter", file: "inter-vietnamese-opsz-italic.woff2", weight: "100 900", style: "italic", unicodeRange: "U+0102-0103,U+0110-0111,U+0128-0129,U+0168-0169,U+01A0-01A1,U+01AF-01B0,U+0300-0301,U+0303-0304,U+0308-0309,U+0323,U+0329,U+1EA0-1EF9,U+20AB" }
+];
+var fontStack = (family) => family.split(",").map((f) => f.trim()).filter(Boolean).map((f) => /^["']/.test(f) || genericFamilies.has(f.toLowerCase()) ? f : `"${f.replace(/"/g, "")}"`).join(", ");
+var lineCache = /* @__PURE__ */ new WeakMap();
+var cleaned = /* @__PURE__ */ new WeakMap();
+var linesFor = (raw, maxWords, fillers2 = false) => {
+  let cues = raw;
+  if (fillers2) {
+    cues = cleaned.get(raw) ?? dropFillerWords(raw);
+    cleaned.set(raw, cues);
+  }
+  let byWords = lineCache.get(cues);
+  if (!byWords) lineCache.set(cues, byWords = /* @__PURE__ */ new Map());
+  let lines = byWords.get(maxWords);
+  if (!lines) byWords.set(maxWords, lines = captionLines(cues, maxWords));
+  return lines;
+};
+function captionAt(layer, seconds3) {
+  const lines = linesFor(layer.cues ?? [], layer.maxWords, layer.dropFillers), t = seconds3 - (layer.offset ?? 0), stress = new Set((layer.emphasis ?? []).map(captionKey)), mark = (w) => stress.size && stress.has(captionKey(w.text)) ? { ...w, emphasis: true } : w;
+  let cue = lines.find((c) => t >= c.start && t < c.end), finished = false;
+  if (!cue) {
+    cue = [...lines].reverse().find((c) => c.end <= t && t - c.end < 0.3);
+    finished = !!cue;
+  }
+  if (!cue) return null;
+  if (layer.mode === "lines" || !cue.words?.length) return { words: cue.text.split(/\s+/).filter(Boolean).map((text) => mark({ text, state: 2 })) };
+  const current = finished ? cue.words.length : cue.words.reduce((at, w, i) => w.start <= t ? i : at, -1);
+  return { words: cue.words.map((w, i) => mark({ text: w.text, state: i < current ? 2 : i === current ? 1 : 0 })) };
+}
+var prepareOperations = (operations, fps = 30) => {
+  for (const op of flattenOperations(operations)) {
+    if (op.kind !== "text" && op.kind !== "captions") continue;
+    const layer = op.layer;
+    op.fontPrefix = `${layer.fontStyle} ${layer.fontWeight}`;
+    op.fontStack = fontStack(layer.fontFamily);
+    if (layer.spans?.length) op.spanStacks = layer.spans.map((span) => fontStack(span.fontFamily ?? layer.fontFamily));
+    if (op.kind === "captions") op.caption = captionAt(layer, (layer.localFrame - layer.startFrame) / fps);
+  }
+  for (const op of flattenOperations(operations)) {
+    const layer = op.layer, own = layer.localFrame - layer.startFrame;
+    if (op.kind === "lottie") op.mediaTime = (layer.trimStart + own * layer.playbackRate) / fps;
+    if (op.kind !== "html" && op.kind !== "shader" && op.kind !== "code" && op.kind !== "react") continue;
+    op.vars = { ...layer.vars, ...Object.fromEntries(Object.entries(layer).filter(([key]) => key.startsWith("--"))), "--t": Math.round(own / fps * 1e6) / 1e6, "--frame": own, ...op.kind === "code" || op.kind === "react" ? { "--fps": fps } : {} };
+  }
+  return operations;
+};
+
+// packages/renderer/src/video.ts
+import { mkdir as mkdir2, readdir as readdir2, rename, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+import { createHash as createHash2, randomUUID } from "node:crypto";
+var videoFrameFile = (video, index) => join4(video.dir, `${String(Math.max(0, index - video.first) + 1).padStart(6, "0")}.jpg`);
+var videoCacheRoot = () => cacheDir("video");
+var complete = ".complete";
+async function decode(source, key, first = 0) {
+  const version = isUrl(source) ? "" : await stat3(source).then((s) => `${s.size}:${s.mtimeMs}`, () => {
+    throw new Error(`Video not found: ${source}`);
+  });
+  const dir = join4(videoCacheRoot(), createHash2("sha256").update(JSON.stringify({ source, version, ...key })).digest("hex").slice(0, 32));
+  const count = async () => (await readdir2(dir)).filter((f) => f.endsWith(".jpg")).length;
+  if (await stat3(join4(dir, complete)).then(() => true, () => false)) {
+    void touchCacheEntry(dir);
+    return { dir, count: first + await count(), first };
+  }
+  const scratch = `${dir}.partial-${randomUUID()}`;
+  await mkdir2(scratch, { recursive: true });
+  try {
+    await extractFrames(source, scratch, key);
+    await writeFile2(join4(scratch, complete), "");
+    await rename(scratch, dir).catch(async (error) => {
+      if (!await stat3(join4(dir, complete)).then(() => true, () => false)) throw error;
+    });
+  } finally {
+    await rm2(scratch, { recursive: true, force: true });
+  }
+  const frames = await count();
+  if (frames === 0) throw new Error(`No frames could be decoded from ${source}`);
+  return { dir, count: first + frames, first };
+}
+async function prepareVideos(composition, baseDir) {
+  const fps = composition.fps, bySource = /* @__PURE__ */ new Map();
+  for (const { layer, startFrame, endFrame } of layerWindows(composition, (l) => l.type === "video")) {
+    const l = layer, first = Math.max(0, Math.floor(l.trimStart)), last = Math.ceil(l.trimStart + (endFrame - startFrame) * l.playbackRate) + 1, seen = bySource.get(l.src);
+    bySource.set(l.src, seen ? { first: Math.min(seen.first, first), last: Math.max(seen.last, last), loop: seen.loop || l.loop } : { first, last, loop: !!l.loop });
+  }
+  return new Map(await Promise.all([...bySource].map(async ([src, range]) => {
+    const source = resolveAssetSource(composition, src, baseDir), size = { fps, maxWidth: composition.width, maxHeight: composition.height };
+    if (range.loop) return [src, await decode(source, size)];
+    const windowed = range.first > 0 ? await decode(source, { ...size, startSeconds: range.first / fps, durationSeconds: (range.last - range.first) / fps }, range.first).catch(() => void 0) : void 0;
+    return [src, windowed ?? await decode(source, { ...size, durationSeconds: range.last / fps })];
+  })));
+}
+
+// packages/renderer/src/pool.ts
+var defaultFrameTimeoutMs = 12e4;
+var message = (error) => String(error?.message ?? error).replace(/^page\.evaluate: (Error: )?/, "").split("\n")[0];
+var isDrawingError = (error) => /^Layer "/.test(message(error));
+async function createPagePool(open, discard, size, timeoutMs = defaultFrameTimeoutMs) {
+  const idle = await Promise.all(Array.from({ length: size }, open));
+  const waiting = [];
+  let alive = size, closed = false, lastOpenError;
+  const acquire = () => idle.pop() ?? new Promise((resolve4, reject) => {
+    if (alive === 0) reject(new Error(`No browser page is available: ${lastOpenError?.message ?? "all failed"}`));
+    else waiting.push({ resolve: resolve4, reject });
+  });
+  const release = (page) => {
+    if (closed) {
+      void discard(page).catch(() => {
+      });
+      return;
+    }
+    const next = waiting.shift();
+    if (next) next.resolve(page);
+    else idle.push(page);
+  };
+  const replace = (page) => {
+    void discard(page).catch(() => {
+    });
+    if (closed) return;
+    open().then(release, (error) => {
+      lastOpenError = error;
+      alive--;
+      if (alive === 0) for (const w of waiting.splice(0)) w.reject(new Error(`Could not open a new browser page: ${error.message}`));
+    });
+  };
+  const withTimeout = (work) => {
+    let timer;
+    return Promise.race([work, new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`the browser page did not answer within ${Math.round(timeoutMs / 1e3)} s`)), timeoutMs);
+    })]).finally(() => clearTimeout(timer));
+  };
+  return {
+    async run(label, work) {
+      for (let attempt = 0; ; attempt++) {
+        const page = await Promise.resolve(acquire()).catch((error) => {
+          throw new Error(`${label}: ${error.message}`);
+        });
+        try {
+          const result = await withTimeout(work(page));
+          release(page);
+          return result;
+        } catch (error) {
+          if (isDrawingError(error)) {
+            release(page);
+            throw new Error(`${label}: ${message(error)}`);
+          }
+          replace(page);
+          if (attempt >= 1 || closed) throw new Error(`${label}: ${message(error)}${attempt ? " (failed again on a fresh browser page)" : ""}`);
+        }
+      }
+    },
+    async close() {
+      closed = true;
+      for (const w of waiting.splice(0)) w.reject(new Error("The renderer was closed"));
+      await Promise.all(idle.splice(0).map((page) => discard(page).catch(() => {
+      })));
+    }
+  };
+}
+
+// packages/graphics/src/fonts.ts
+import { existsSync } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join as join5 } from "node:path";
+import { fileURLToPath } from "node:url";
+function builtinFontDir() {
+  const bundled = fileURLToPath(new URL("./fonts/", import.meta.url));
+  if (existsSync(join5(bundled, builtinFontFaces[0].file))) return bundled;
+  return join5(dirname(createRequire(import.meta.url).resolve("@fontsource-variable/inter/package.json")), "files");
+}
+var cached;
+var builtinFonts = () => cached ??= Promise.all(builtinFontFaces.map(async (face) => ({ ...face, src: `builtin:${face.file}`, url: `data:font/woff2;base64,${(await readFile3(join5(builtinFontDir(), face.file))).toString("base64")}` })));
+
+// packages/graphics/src/runtime.ts
+import { existsSync as existsSync2, readFileSync } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { join as join6 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+var runtimeDir = () => {
+  const bundled = fileURLToPath2(new URL("./runtime/", import.meta.url));
+  return existsSync2(join6(bundled, "canvas-runtime.js")) ? bundled : fileURLToPath2(new URL("../runtime/", import.meta.url));
+};
+var read = (name2) => readFileSync(join6(runtimeDir(), name2), "utf8");
+var textLayoutSource = read("text-layout.js");
+var lottieFile = "lottie_light_canvas.min.js";
+var lottiePath = () => {
+  const bundled = join6(runtimeDir(), lottieFile);
+  return existsSync2(bundled) ? bundled : createRequire2(import.meta.url).resolve(`lottie-web/build/player/${lottieFile}`);
+};
+var lottieSource = readFileSync(lottiePath(), "utf8");
+var canvasRuntimeSource = `${textLayoutSource}
+${read("canvas-runtime.js")}`;
+var layoutText = new Function(`${textLayoutSource}; return layoutText;`)();
+var layoutRich = new Function(`${textLayoutSource}; return layoutRich;`)();
+
+// packages/renderer/src/index.ts
+var scaledSize = (composition, scale = 1) => ({ width: Math.max(2, Math.round(composition.width * scale / 2) * 2), height: Math.max(2, Math.round(composition.height * scale / 2) * 2) });
+var runtime = `<!doctype html><canvas id="c"></canvas><script>${lottieSource}</script><svg width="0" height="0" style="position:absolute"><path id="measure"/></svg><script>
+${canvasRuntimeSource}
+const rt=createCanvasRuntime(document.querySelector('#c'),document.querySelector('#measure'));
+window.OVE={load:rt.load,draw:async(p)=>{await rt.draw(p);return rt.canvas.toDataURL('image/png').slice('data:image/png;base64,'.length)},inspect:async(p)=>{await rt.draw({...p,report:true});return rt.report()}};</script>`;
+var sheetPage = `<!doctype html><canvas id="s"></canvas><script>window.sheet=async({images,labels,columns,cell})=>{const c=document.querySelector('#s'),rows=Math.ceil(images.length/columns),gap=8,label=26,ctx=c.getContext('2d');c.width=columns*cell.w+(columns+1)*gap;c.height=rows*(cell.h+label)+(rows+1)*gap;ctx.fillStyle='#0b0d14';ctx.fillRect(0,0,c.width,c.height);ctx.font='600 15px system-ui,sans-serif';ctx.textBaseline='middle';
+for(let i=0;i<images.length;i++){const img=new Image();img.src=images[i];await img.decode();const x=gap+(i%columns)*(cell.w+gap),y=gap+Math.floor(i/columns)*(cell.h+label+gap);ctx.drawImage(img,x,y,cell.w,cell.h);ctx.fillStyle='#c9cfdd';ctx.fillText(labels[i],x+2,y+cell.h+label/2)}return c.toDataURL('image/png').slice(22)}</script>`;
+var allLayers = (composition) => composition.scenes.flatMap((scene) => scene.layers);
+var browserArgs = ["--use-angle=swiftshader", "--enable-unsafe-swiftshader", ...(process.env.OVE_CHROMIUM_ARGS ?? "").split(/\s+/).filter(Boolean)];
+var browserInstallHint = `Install one with "ove browser install" (Playwright's Chromium, about 150 MB), install Google Chrome, or set OVE_CHROMIUM_EXECUTABLE to a Chromium-based browser.`;
+async function launchBrowser() {
+  const explicit = process.env.OVE_CHROMIUM_EXECUTABLE;
+  if (explicit) {
+    if (!existsSync3(explicit)) throw new Error(`OVE_CHROMIUM_EXECUTABLE points to ${explicit}, which does not exist.`);
+    return chromium.launch({ headless: true, executablePath: explicit, args: browserArgs });
+  }
+  if (existsSync3(chromium.executablePath())) return chromium.launch({ headless: true, args: browserArgs });
+  for (const channel of ["chrome", "msedge"]) {
+    try {
+      return await chromium.launch({ headless: true, channel, args: browserArgs });
+    } catch {
+    }
+  }
+  throw new Error(`No Chromium-based browser was found. ${browserInstallHint}`);
+}
+async function describeBrowser() {
+  const browser = await launchBrowser();
+  try {
+    return `${browser.browserType().name()} ${browser.version()}${process.env.OVE_CHROMIUM_EXECUTABLE ? ` (OVE_CHROMIUM_EXECUTABLE=${process.env.OVE_CHROMIUM_EXECUTABLE})` : existsSync3(chromium.executablePath()) ? " (Playwright Chromium)" : " (installed Chrome/Edge)"}`;
+  } finally {
+    await browser.close();
+  }
+}
+var defaultConcurrency = () => Math.max(1, Math.min(4, Math.floor(availableParallelism() / 2)));
+async function createRenderer(composition, options = {}) {
+  const baseDir = options.baseDir ?? process.cwd();
+  if (hasCodeLayers(composition.scenes.flatMap((s) => s.layers)) && !options.allowCode) throw new Error("This composition has code layers, which run JavaScript while rendering. Render it only if you trust it, with --allow-code (or allowCode: true).");
+  const concurrency = Math.max(1, Math.floor(options.concurrency ?? 1));
+  const output = scaledSize(composition, options.scale ?? composition.export.scale);
+  const videos = await prepareVideos(composition, baseDir);
+  const sources = Object.fromEntries(await Promise.all(collectImageSources(allLayers(composition)).map(async (src) => [src, await toDataUrl(resolveAssetSource(composition, src, baseDir))])));
+  const fonts = [...await builtinFonts(), ...await Promise.all(composition.assets.filter((a) => a.type === "font").map(async (a) => ({ family: a.family ?? a.id, src: a.src, weight: a.weight ?? 400, style: a.style ?? "normal", url: await toDataUrl(resolveAssetSource(composition, a.src, baseDir)) })))];
+  const reactImages = hasReactLayers(allLayers(composition)) ? Object.fromEntries(await Promise.all(composition.assets.filter((a) => a.type === "image").flatMap((a) => [a.id, a.src]).map(async (key) => [key, await toDataUrl(resolveAssetSource(composition, key, baseDir))]))) : {};
+  const codes = Object.fromEntries(await Promise.all(collectCodeSources(allLayers(composition)).map(async (src) => {
+    const file = resolveAssetSource(composition, src, baseDir);
+    try {
+      return [src, { text: await readFile4(file, "utf8") }];
+    } catch (error) {
+      throw new Error(`Code ${src} could not be read from ${file}: ${error.message}`);
+    }
+  })));
+  const lotties = Object.fromEntries(await Promise.all(collectLottieSources(allLayers(composition)).map(async (src) => {
+    const file = resolveAssetSource(composition, src, baseDir);
+    try {
+      return [src, JSON.parse(await readFile4(file, "utf8"))];
+    } catch (error) {
+      throw new Error(`Lottie ${src} could not be read from ${file}: ${error.message}`);
+    }
+  })));
+  const browser = await launchBrowser();
+  try {
+    const openPage = async () => {
+      const context = await browser.newContext({ viewport: output, deviceScaleFactor: 1 });
+      if (Object.keys(codes).length || hasCodeLayers(composition.scenes.flatMap((s) => s.layers))) await context.route(/^(https?|wss?|ftp):/i, (route) => route.abort());
+      const page = await context.newPage();
+      await page.setContent(runtime, { waitUntil: "load" });
+      await page.evaluate(async ({ sources: sources2, fonts: fonts2, lotties: lotties2, codes: codes2 }) => {
+        await window.OVE.load(sources2, fonts2, lotties2, codes2);
+      }, { sources: { ...sources, ...reactImages }, fonts, lotties, codes });
+      return page;
+    };
+    const pool = await createPagePool(openPage, (page) => page.context().close(), concurrency, options.frameTimeoutMs ?? (Number(process.env.OVE_FRAME_TIMEOUT_MS) || defaultFrameTimeoutMs));
+    const attachVideoFrames = async (operations) => {
+      const videoFrames = {};
+      for (const op of flattenOperations(operations).filter((op2) => op2.kind === "video")) {
+        const layer = op.layer, video = videos.get(layer.src);
+        const index = videoFrameIndex(layer, layer.localFrame - layer.startFrame, video.count);
+        op.frameKey = `${layer.src}#${index}`;
+        videoFrames[op.frameKey] ??= `data:image/jpeg;base64,${(await readFile4(videoFrameFile(video, index))).toString("base64")}`;
+      }
+      return videoFrames;
+    };
+    const blur = options.motionBlur === false ? void 0 : composition.motionBlur;
+    const payload = async (frame, sharp = false) => {
+      const operations = prepareOperations(toDrawOperations(evaluateFrame(composition, frame)), composition.fps);
+      const videoFrames = await attachVideoFrames(operations);
+      let subframes;
+      if (blur && !sharp) {
+        subframes = [];
+        for (let i = 0; i < blur.samples; i++) {
+          const t = Math.min(composition.durationFrames - 1e-6, frame + i / blur.samples * blur.shutter / 360);
+          const ops = i === 0 ? operations : prepareOperations(toDrawOperations(evaluateFrame(composition, t)), composition.fps);
+          if (i > 0) Object.assign(videoFrames, await attachVideoFrames(ops));
+          subframes.push({ operations: ops });
+        }
+      }
+      return { width: output.width, height: output.height, scaleX: output.width / composition.width, scaleY: output.height / composition.height, background: composition.background, transparent: composition.export.transparent, grain: composition.grain, frame, operations, videoFrames, subframes };
+    };
+    const renderFrame = async (frame) => {
+      const p = await payload(frame);
+      const png = await pool.run(`Frame ${frame}`, (page) => page.evaluate((p2) => window.OVE.draw(p2), p));
+      return Buffer.from(png, "base64");
+    };
+    const inspectFrame = async (frame) => {
+      const p = await payload(frame, true);
+      return pool.run(`Frame ${frame}`, (page) => page.evaluate((p2) => window.OVE.inspect(p2), p));
+    };
+    const contactSheet = async (frames, options2 = {}) => {
+      const columns = Math.max(1, Math.min(options2.columns ?? 5, frames.length)), cellWidth = Math.round((options2.width ?? 1800) / columns), cell = { w: cellWidth, h: Math.round(cellWidth * composition.height / composition.width) };
+      const images = await Promise.all(frames.map(async (f) => `data:image/png;base64,${(await renderFrame(f)).toString("base64")}`)), labels = frames.map((f) => `${f}  \xB7  ${(f / composition.fps).toFixed(1)} s`);
+      const context = await browser.newContext();
+      try {
+        const page = await context.newPage();
+        await page.setContent(sheetPage);
+        return Buffer.from(await page.evaluate((a) => window.sheet(a), { images, labels, columns, cell }), "base64");
+      } finally {
+        await context.close();
+      }
+    };
+    return { concurrency, renderFrame, inspectFrame, contactSheet, async captureFrame(frame, output2) {
+      await writeFile3(output2, await renderFrame(frame));
+    }, close: async () => {
+      await pool.close();
+      await browser.close();
+    } };
+  } catch (error) {
+    await browser.close();
+    throw error;
+  }
+}
+async function* renderFrames(renderer, from, to, options = {}) {
+  const lookahead = Math.max(1, options.lookahead ?? renderer.concurrency * 4);
+  const pending = [];
+  let next = from;
+  const fill = () => {
+    while (next < to && pending.length < lookahead) {
+      const job = renderer.renderFrame(next++);
+      job.catch(() => {
+      });
+      pending.push(job);
+    }
+  };
+  try {
+    fill();
+    while (pending.length) {
+      const png = await pending.shift();
+      fill();
+      yield png;
+    }
+  } finally {
+    await Promise.allSettled(pending);
+  }
+}
+
+// packages/core/src/audio.ts
+import { stat as stat4 } from "node:fs/promises";
+import { spawn as spawn3 } from "node:child_process";
+import { mkdtemp, rm as rm3, mkdir as mkdir3, rename as rename2 } from "node:fs/promises";
+import { existsSync as existsSync4 } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join7 } from "node:path";
+var runFfmpeg = (args) => new Promise((resolve4, reject) => {
+  const child = spawn3(ffmpegPath(), args, { stdio: ["ignore", "ignore", "pipe"] });
+  let err = "";
+  child.stderr.on("data", (d) => err += d);
+  child.on("error", reject);
+  child.on("close", (code) => code === 0 ? resolve4(err) : reject(new Error(`FFmpeg exited ${code}: ${err.slice(-500)}`)));
+});
+var sfxDir = () => cacheDir("sfx");
+var making = /* @__PURE__ */ new Map();
+function sfxFile(name2) {
+  const file = join7(sfxDir(), `${name2}-${createHash3("sha256").update(JSON.stringify(sfxArgs(name2, ""))).digest("hex").slice(0, 12)}.wav`);
+  if (existsSync4(file)) {
+    void touchCacheEntry(file);
+    return Promise.resolve(file);
+  }
+  let job = making.get(file);
+  if (!job) {
+    job = (async () => {
+      await mkdir3(sfxDir(), { recursive: true });
+      const temp = `${file}.${process.pid}.tmp.wav`;
+      await runFfmpeg(sfxArgs(name2, temp));
+      await rename2(temp, file);
+      return file;
+    })();
+    making.set(file, job);
+    job.catch(() => making.delete(file));
+  }
+  return job;
+}
+var sourceOf = (composition, src, baseDir) => isBuiltinSound(src) ? sfxFile(builtinSoundName(src)) : Promise.resolve(resolveAssetSource(composition, src, baseDir));
+var ensureExists = async (source) => {
+  if (!isUrl(source)) await stat4(source).catch(() => {
+    throw new Error(`Audio source not found: ${source}`);
+  });
+};
+async function planAudio(composition, baseDir, probe2 = hasAudioStream) {
+  const fps = composition.fps, clips = [], windows = audioWindows(composition);
+  const ducking = !!composition.export.duck || windows.some(({ layer }) => layer.duck);
+  const media = {};
+  if (ducking) await Promise.all([...new Set(windows.map(({ layer }) => layer.src))].map(async (src) => {
+    const m = await measureSource(await sourceOf(composition, src, baseDir));
+    media[src] = { duration: m.duration, segments: m.sounds.map(([start, end]) => ({ start, end })) };
+  }));
+  const others = ducking ? soundIntervals(composition, media) : [];
+  const soundtrack = composition.export.audio === void 0 ? void 0 : await sourceOf(composition, composition.export.audio, baseDir);
+  if (soundtrack) {
+    await ensureExists(soundtrack);
+    const duration = composition.durationFrames / fps;
+    clips.push({ source: soundtrack, start: 0, duration, loop: true, volume: composition.export.audioVolume, envelope: volumeEnvelope({ layer: { volume: composition.export.audioVolume }, fps, start: 0, duration, duck: composition.export.duck, others }) });
+  }
+  const hasAudio = /* @__PURE__ */ new Map();
+  for (const { layer, startFrame, endFrame } of windows) {
+    const source = await sourceOf(composition, layer.src, baseDir);
+    await ensureExists(source);
+    if (layer.type === "video") {
+      if (!hasAudio.has(source)) hasAudio.set(source, probe2(source));
+      if (!await hasAudio.get(source)) continue;
+    }
+    const start = startFrame / fps, duration = (endFrame - startFrame) / fps;
+    clips.push({ source, start, duration, trim: layer.trimStart / fps, rate: layer.playbackRate, loop: layer.loop, volume: layer.volume, envelope: volumeEnvelope({ layer, fps, start, duration, duck: layer.duck, others }), ...layer.type === "audio" ? { fadeIn: layer.fadeInFrames / fps, fadeOut: layer.fadeOutFrames / fps } : {} });
+  }
+  return clips.length ? { clips, durationSeconds: composition.durationFrames / fps } : void 0;
+}
+async function measureMix(mix) {
+  if (!mix.clips.length) return void 0;
+  const dir = await mkdtemp(join7(tmpdir2(), "ove-loudness-")), wav = join7(dir, "mix.wav");
+  try {
+    const args = audioMixArgs(mix, ["-c:a", "pcm_s16le"]), video = args.indexOf("0:v");
+    if (video > 0) args.splice(video - 1, 2);
+    await runFfmpeg(["-v", "error", "-y", "-f", "lavfi", "-i", "color=c=black:s=16x16:r=1", ...args, "-t", String(mix.durationSeconds), wav]);
+    const summary = (await runFfmpeg(["-hide_banner", "-nostats", "-i", wav, "-af", "ebur128=peak=true", "-f", "null", "-"])).split("Summary:").at(-1) ?? "";
+    const integrated = Number(/I:\s+(-?[\d.]+|-inf) LUFS/.exec(summary)?.[1]), truePeak = Number(/Peak:\s+(-?[\d.]+|-inf) dBFS/.exec(summary)?.[1]);
+    return Number.isFinite(integrated) ? { integrated, truePeak: Number.isFinite(truePeak) ? truePeak : -Infinity } : void 0;
+  } finally {
+    await rm3(dir, { recursive: true, force: true });
+  }
+}
+async function masterAudio(composition, baseDir) {
+  const mix = await planAudio(composition, baseDir), target = composition.export.loudness;
+  if (!mix || target === void 0) return mix;
+  const measured = await measureMix({ ...mix, durationSeconds: composition.durationFrames / composition.fps });
+  return measured ? { ...mix, gainDb: Math.max(-40, Math.min(40, target - measured.integrated)) } : mix;
+}
+async function measureLoudness(composition, baseDir) {
+  const mix = await masterAudio(composition, baseDir);
+  return mix ? measureMix({ ...mix, durationSeconds: composition.durationFrames / composition.fps }) : void 0;
+}
+
+// packages/core/src/review.ts
+var area = (a) => Math.max(0, a.x1 - a.x0) * Math.max(0, a.y1 - a.y0);
+var overlap = (a, b) => Math.max(0, Math.min(a.x1, b.x1) - Math.max(a.x0, b.x0)) * Math.max(0, Math.min(a.y1, b.y1) - Math.max(a.y0, b.y0));
+var seconds2 = (frame, fps) => `${(frame / fps).toFixed(1)} s`;
+async function reviewComposition(composition, options = {}) {
+  const { fps, width, height, durationFrames } = composition, baseDir = options.baseDir ?? process.cwd();
+  const every = Math.max(1, Math.round(options.every ?? fps / 2)), frames = [];
+  for (let f = 0; f < durationFrames; f += every) frames.push(f);
+  if (frames.at(-1) !== durationFrames - 1) frames.push(durationFrames - 1);
+  const sheetCount = Math.max(1, Math.min(options.sheetFrames ?? 20, durationFrames)), sheetFrames = Array.from({ length: sheetCount }, (_, i) => Math.min(durationFrames - 1, Math.round((i + 0.5) * durationFrames / sheetCount)));
+  const renderer = await createRenderer(composition, { baseDir, concurrency: options.concurrency ?? defaultConcurrency(), scale: Math.min(1, 1280 / Math.max(width, height)), allowCode: options.allowCode });
+  let reports = [], sheet;
+  try {
+    let done = 0;
+    reports = await Promise.all(frames.map((f) => renderer.inspectFrame(f).then((r) => {
+      options.onProgress?.(++done, frames.length);
+      return r;
+    })));
+    sheet = await renderer.contactSheet(sheetFrames, { columns: options.columns ?? (width >= height ? 4 : 6) });
+  } finally {
+    await renderer.close();
+  }
+  const issues = [], minSide = Math.min(width, height), visible = (t) => t.alpha >= 0.95;
+  const persistent = (code, hold2, test, severity) => {
+    const runs = /* @__PURE__ */ new Map(), reported = /* @__PURE__ */ new Set();
+    reports.forEach((report, i) => {
+      const seen = /* @__PURE__ */ new Set();
+      for (const t of report.texts) {
+        const message2 = test(t, report);
+        if (!message2) continue;
+        const key = `${t.id}|${message2}`;
+        seen.add(key);
+        const run3 = runs.get(key) ?? { start: frames[i], count: 0, message: message2 };
+        run3.count++;
+        runs.set(key, run3);
+        if (run3.count >= hold2 && !reported.has(`${t.id}|${t.text}`)) {
+          reported.add(`${t.id}|${t.text}`);
+          issues.push({ severity, code, message: message2, frame: run3.start, layer: t.id });
+        }
+      }
+      for (const key of runs.keys()) if (!seen.has(key)) runs.delete(key);
+    });
+  };
+  const hold = Math.max(2, Math.ceil(fps / every) + 1), margin = 0.01 * minSide, smallest = minSide * 0.018;
+  persistent("text-cut", 1, (t) => t.truncated ? `"${t.text}" is cut short with "\u2026": give it more room (maxWidth/maxLines) or a minFontSize` : void 0, "error");
+  persistent("off-frame", hold, (t) => visible(t) && (t.x0 < -margin || t.y0 < -margin || t.x1 > width + margin || t.y1 > height + margin) ? `"${t.text}" runs off the frame` : void 0, "error");
+  persistent("small-text", hold, (t) => visible(t) && t.size < smallest ? `"${t.text}" is ${Math.round(t.size)} px, too small to read on a phone (labels ${Math.ceil(smallest)}+ px, body ${Math.round(minSide * 0.024)}+ px)` : void 0, "warning");
+  persistent("overlap", hold, (t, report) => {
+    if (!visible(t)) return;
+    const other = report.texts.find((o) => o !== t && o.id !== t.id && visible(o) && overlap(t, o) > 0.15 * Math.min(area(t), area(o)) && (t.kind === "captions" || o.kind === "captions" || t.id < o.id));
+    return other ? t.kind === "captions" || other.kind === "captions" ? `"${(t.kind === "captions" ? other : t).text}" sits under the captions: keep content out of the captions band` : `"${t.text}" overlaps "${other.text}"` : void 0;
+  }, "error");
+  const crowded = reports.map((r) => r.texts.filter((t) => visible(t) && t.kind === "text").reduce((n, t) => n + t.words, 0) > 40), busy = crowded.findIndex((_, i) => i + hold <= crowded.length && crowded.slice(i, i + hold).every(Boolean));
+  if (busy >= 0) issues.push({ severity: "warning", code: "busy", message: `More than 40 words on screen at ${seconds2(frames[busy], fps)}: split it across beats or cut words`, frame: frames[busy] });
+  const texts = reports.flatMap((r) => r.texts).filter((t) => visible(t) && t.kind === "text"), sizes = [...new Set(texts.map((t) => Math.round(t.baseSize)))].sort((a, b) => b - a), colours = [...new Set(texts.map((t) => t.color.toLowerCase()).filter((c) => c !== "gradient"))];
+  const steps = [];
+  for (const size of sizes) {
+    const step = steps.at(-1);
+    if (step && step[0] / size <= 1.12) step.push(size);
+    else steps.push([size]);
+  }
+  const near = steps.filter((s) => s.length > 1);
+  if (steps.length > 8) issues.push({ severity: "warning", code: "type-scale", message: `${steps.length} steps of font size (${steps.map((s) => s.join("/")).join(", ")}): pick a scale of 5\u20138 sizes and reuse them` });
+  else if (near.length) issues.push({ severity: "warning", code: "type-scale", message: `Nearly equal font sizes (${near.map((s) => s.join("/")).join(", ")}): use one size for each step of the type scale` });
+  if (colours.length > 5) issues.push({ severity: "warning", code: "text-colours", message: `${colours.length} text colours (${colours.join(", ")}): use a heading colour, a body colour and one or two accents` });
+  const change = reports.slice(1).map((r, i) => {
+    const a = reports[i].thumb.pixels, b = r.thumb.pixels;
+    let sum = 0;
+    for (let k = 0; k < a.length; k++) sum += Math.abs(a[k] - b[k]);
+    return sum / a.length;
+  });
+  let still = -1;
+  for (let i = 0; i <= change.length; i++) {
+    const isStill = i < change.length && change[i] < 0.5;
+    if (isStill && still < 0) still = i;
+    if (!isStill && still >= 0) {
+      const from = frames[still], to = frames[i];
+      if (to - from >= (to >= durationFrames - 1 ? 6 : 4) * fps) issues.push({ severity: "warning", code: "frozen", message: `Nothing moves from ${seconds2(from, fps)} to ${seconds2(to, fps)}: add slow drift or a beat, or shorten the hold`, frame: from });
+      still = -1;
+    }
+  }
+  const lengths = composition.scenes.map((s) => s.durationFrames), mean = lengths.reduce((a, b) => a + b, 0) / lengths.length;
+  if (lengths.length >= 4 && lengths.every((l) => Math.abs(l - mean) <= 0.1 * mean)) issues.push({ severity: "warning", code: "uniform-scenes", message: `All ${lengths.length} scenes are about ${seconds2(Math.round(mean), fps)} long: vary their length so the video has a rhythm` });
+  const transitions = [...new Set(composition.scenes.flatMap((s) => [s.transitionIn?.type, s.transitionOut?.type]).filter(Boolean))];
+  if (transitions.length >= 3) issues.push({ severity: "info", code: "mixed-transitions", message: `${transitions.length} transition styles (${transitions.join(", ")}): one style through a video usually reads as more deliberate` });
+  const loudness = options.audio === false ? void 0 : await measureLoudness(composition, baseDir);
+  if (loudness) {
+    if (loudness.integrated < -20) issues.push({ severity: "warning", code: "quiet", message: `Sound is quiet (${loudness.integrated.toFixed(1)} LUFS): set export.loudness (-14 for social video, -16 for explainers) or raise volumes` });
+    else if (loudness.integrated > -11) issues.push({ severity: "warning", code: "loud", message: `Sound is loud (${loudness.integrated.toFixed(1)} LUFS): set export.loudness (-14 for social video, -16 for explainers) or lower volumes` });
+    if (loudness.truePeak > -1) issues.push({ severity: "warning", code: "peaks", message: `Sound peaks at ${loudness.truePeak.toFixed(1)} dBTP and may distort after upload: keep peaks under -1 dBTP (lower volume)` });
+  }
+  const stretches = /* @__PURE__ */ new Map();
+  reports.forEach((report, i) => {
+    const here = /* @__PURE__ */ new Set();
+    for (const t of report.texts) {
+      if (!visible(t) || t.kind !== "text" || t.words < 3) continue;
+      const key = `${t.id}|${t.text}`;
+      here.add(key);
+      const s = stretches.get(key) ?? { text: t.text, words: t.words, best: 0, run: 0, first: frames[i], start: frames[i], layer: t.id };
+      if (s.run === 0) s.start = frames[i];
+      s.run++;
+      if (s.run > s.best) {
+        s.best = s.run;
+        s.first = s.start;
+      }
+      stretches.set(key, s);
+    }
+    for (const [key, s] of stretches) if (!here.has(key)) s.run = 0;
+  });
+  for (const s of stretches.values()) {
+    const shown = s.best * every / fps, needs = 0.5 + s.words * 0.25;
+    if (shown < needs && s.first + s.best * every < durationFrames - 1) issues.push({ severity: "warning", code: "read-time", message: `"${s.text}" is readable for about ${shown.toFixed(1)} s; its ${s.words} words need about ${needs.toFixed(1)} s: hold it longer or cut words`, frame: s.first, layer: s.layer });
+  }
+  const clusters = (texts2) => {
+    const groups = [];
+    for (const t of [...texts2].sort((a, b) => a.y0 - b.y0)) {
+      const near2 = groups.find((g) => g.some((o) => t.y0 - o.y1 < 0.5 * Math.min(t.size, o.size) && o.y0 - t.y1 < 0.5 * Math.min(t.size, o.size) && Math.min(t.x1, o.x1) > Math.max(t.x0, o.x0)));
+      if (near2) near2.push(t);
+      else groups.push([t]);
+    }
+    return groups;
+  };
+  const headlines = reports.map((r) => clusters(r.texts.filter((t) => visible(t) && t.kind === "text" && t.size >= minSide * 0.06)).map((g) => ({ text: g.map((t) => t.text).join(" ") }))), crowdedHeads = headlines.findIndex((_, i) => i + hold <= headlines.length && headlines.slice(i, i + hold).every((h) => h.length > 2));
+  if (crowdedHeads >= 0) issues.push({ severity: "warning", code: "headlines", message: `${headlines[crowdedHeads].length} headline-size texts at once at ${seconds2(frames[crowdedHeads], fps)} (${headlines[crowdedHeads].map((t) => `"${t.text}"`).join(", ")}): give the frame one hero and make the rest smaller`, frame: frames[crowdedHeads] });
+  let flashes = 0, fastest = 0, fastestAt = -1;
+  for (const cue of captionTrack(composition)) {
+    const length = cue.end - cue.start, cps = cue.text.length / Math.max(0.01, length);
+    if (length < 0.7) flashes++;
+    if (cps > fastest) {
+      fastest = cps;
+      fastestAt = Math.round(cue.start * fps);
+    }
+  }
+  if (flashes) issues.push({ severity: "warning", code: "caption-flash", message: `${flashes} caption line${flashes === 1 ? " is" : "s are"} on screen for under 0.7 s: raise maxWords so short phrases join their neighbours` });
+  if (fastest > 20) issues.push({ severity: "warning", code: "caption-speed", message: `Captions reach ${fastest.toFixed(0)} characters a second at ${seconds2(fastestAt, fps)} (comfortable reading is up to about 20): lower maxWords or slow the voice`, frame: fastestAt });
+  for (const { layer, endFrame, startFrame } of layerWindows(composition, (l) => l.type === "audio" && !l.loop)) {
+    const l = layer;
+    const measured = await measureSource(await sourceOf(composition, l.src, baseDir)).catch(() => void 0);
+    if (!measured) continue;
+    const from = l.trimStart / fps, until = from + (endFrame - startFrame) / fps * l.playbackRate, cut = measured.sounds.find(([a, b]) => a < until - 0.05 && b > until + 0.15);
+    if (cut && endFrame < durationFrames) issues.push({ severity: "warning", code: "sound-cut", message: `"${l.id}" (${l.src}) is cut off mid-sound at ${seconds2(endFrame, fps)}, ${(cut[1] - until).toFixed(1)} s before its phrase ends: lengthen its scene or end it at a pause`, frame: endFrame, layer: l.id });
+  }
+  const order = { error: 0, warning: 1, info: 2 };
+  issues.sort((a, b) => order[a.severity] - order[b.severity] || (a.frame ?? -1) - (b.frame ?? -1));
+  return { issues, sheet, sheetFrames, sampledFrames: frames.length, loudness };
+}
+
+// packages/core/src/distributed.ts
+import { mkdtemp as mkdtemp2, rm as rm4, writeFile as writeFile4, mkdir as mkdir4 } from "node:fs/promises";
+import { tmpdir as tmpdir3 } from "node:os";
+import { dirname as dirname2, extname as extname2, isAbsolute as isAbsolute2, join as join8, resolve as resolve2 } from "node:path";
+import { timingSafeEqual } from "node:crypto";
+function planChunks(first, last, chunkSize) {
+  if (!Number.isInteger(chunkSize) || chunkSize < 1) throw new Error("Chunk size must be a positive whole number of frames");
+  const jobs = [];
+  for (let start = first, index = 0; start <= last; start += chunkSize, index++) jobs.push({ index, frameRange: [start, Math.min(last, start + chunkSize - 1)] });
+  return jobs;
+}
+function absolutizeSources(composition, baseDir) {
+  const abs = (src) => isUrl(src) || isAbsolute2(src) || isBuiltinSound(src) || composition.assets.some((a) => a.id === src) ? src : resolve2(baseDir, src);
+  const fix = (layer) => ({ ...layer, ...typeof layer.src === "string" ? { src: abs(layer.src) } : {}, ...layer.children ? { children: layer.children.map(fix) } : {} });
+  return { ...composition, assets: composition.assets.map((a) => ({ ...a, src: isUrl(a.src) || isAbsolute2(a.src) ? a.src : resolve2(baseDir, a.src) })), scenes: composition.scenes.map((s) => ({ ...s, layers: s.layers.map(fix) })), export: { ...composition.export, audio: composition.export.audio && !composition.assets.some((a) => a.id === composition.export.audio) ? abs(composition.export.audio) : composition.export.audio } };
+}
+async function renderDistributed(composition, options) {
+  const baseDir = options.baseDir ?? process.cwd(), output = resolve2(options.output);
+  if (!options.workers.length) throw new Error("No workers given");
+  const extension = extname2(output).toLowerCase(), byExtension2 = { ".mp4": "mp4", ".webm": "webm", ".mov": "mov", ".gif": "gif" };
+  const format = options.format ?? byExtension2[extension] ?? (extension === "" ? "png" : composition.export.format);
+  if (format !== "mp4" && format !== "webm" && format !== "mov") throw new Error(`Distributed rendering writes mp4, webm or mov (segments are joined without re-encoding); ${format} is not supported`);
+  const settings = exportSchema.parse({ ...composition.export, ...Object.fromEntries(Object.entries({ crf: options.crf, bitrate: options.bitrate, audioBitrate: options.audioBitrate, scale: options.scale, loudness: options.loudness }).filter(([, v]) => v !== void 0)), format, codec: options.codec ?? (format === "mp4" ? composition.export.codec : "h264"), transparent: options.transparent ?? composition.export.transparent });
+  const target = absolutizeSources({ ...composition, export: settings, ...options.motionBlur === false ? { motionBlur: void 0 } : {} }, baseDir), [first, last] = options.frameRange ?? [0, composition.durationFrames - 1];
+  if (!Number.isInteger(first) || !Number.isInteger(last) || first < 0 || last < first || last >= composition.durationFrames) throw new Error(`Frame range must be within 0\u2013${composition.durationFrames - 1}`);
+  const chunkSettings = { format, codec: settings.codec, transparent: settings.transparent, preset: options.preset ?? defaultPreset, crf: settings.crf, bitrate: settings.bitrate, scale: settings.scale };
+  const jobs = planChunks(first, last, options.chunkSize ?? Math.max(30, Math.ceil((last - first + 1) / (options.workers.length * 2)))), total = last - first + 1, retries = options.retries ?? 2;
+  const work = await mkdtemp2(join8(tmpdir3(), "ove-chunks-")), segments = new Array(jobs.length), attempts = /* @__PURE__ */ new Map();
+  const abort = new AbortController();
+  const onOuterAbort = () => abort.abort(options.signal?.reason);
+  options.signal?.addEventListener("abort", onOuterAbort);
+  try {
+    const queue = [...jobs];
+    let rendered = 0, fatal;
+    let alive = options.workers.length;
+    await Promise.all(options.workers.map(async (worker) => {
+      let failures = 0;
+      while (!fatal && !abort.signal.aborted && queue.length) {
+        const job = queue.shift();
+        try {
+          const bytes = await worker.renderChunk(target, job, chunkSettings, abort.signal);
+          const file = join8(work, `chunk-${String(job.index).padStart(5, "0")}.${format}`);
+          await writeFile4(file, bytes);
+          segments[job.index] = file;
+          failures = 0;
+          rendered += job.frameRange[1] - job.frameRange[0] + 1;
+          options.onProgress?.({ frame: job.frameRange[1], rendered, total, chunk: job.index, worker: worker.name });
+        } catch (error) {
+          if (abort.signal.aborted) break;
+          options.onWorkerError?.(worker.name, error);
+          const n = (attempts.get(job.index) ?? 0) + 1;
+          attempts.set(job.index, n);
+          if (n > retries) {
+            fatal = new Error(`Chunk ${job.index} (frames ${job.frameRange[0]}\u2013${job.frameRange[1]}) failed ${n} times; last error from ${worker.name}: ${error.message}`);
+            abort.abort(fatal);
+            break;
+          }
+          queue.unshift(job);
+          if (++failures >= 2) {
+            alive--;
+            if (alive === 0) {
+              fatal = new Error(`Every worker failed; last error from ${worker.name}: ${error.message}`);
+              abort.abort(fatal);
+            }
+            break;
+          }
+        }
+      }
+    }));
+    if (fatal) throw fatal;
+    if (options.signal?.aborted) throw options.signal.reason ?? new Error("Render cancelled");
+    if (segments.some((s) => !s)) throw new Error("Some chunks were not rendered");
+    await mkdir4(dirname2(output), { recursive: true });
+    const audio = await masterAudio(target, baseDir).then((mix) => mix && { ...mix, durationSeconds: total / composition.fps, offsetSeconds: first / composition.fps });
+    await concatSegments(segments, join8(work, "segments.txt"), output, audio, { format, audioBitrate: settings.audioBitrate });
+    return { output, format, frames: total, durationSeconds: Number(await probe(output)) || total / composition.fps };
+  } finally {
+    options.signal?.removeEventListener("abort", onOuterAbort);
+    await rm4(work, { recursive: true, force: true });
+  }
+}
+function httpWorker(url, token) {
+  const base = url.replace(/\/+$/, "");
+  return { name: base, async renderChunk(composition, job, settings, signal) {
+    const response = await fetch(`${base}/render`, { method: "POST", signal, headers: { "content-type": "application/json", authorization: `Bearer ${token}` }, body: JSON.stringify({ composition, frameRange: job.frameRange, ...settings }) });
+    if (!response.ok) throw new Error(`${response.status} ${(await response.text()).slice(0, 500)}`);
+    return Buffer.from(await response.arrayBuffer());
+  } };
+}
+var tokensMatch = (given, expected) => {
+  const a = Buffer.from(given), b = Buffer.from(expected);
+  return a.length === b.length && timingSafeEqual(a, b);
+};
+
+// packages/core/src/index.ts
+async function loadCompositionFile(path, values = {}) {
+  const file = resolve3(path), baseDir = dirname3(file);
+  return { composition: await prepareComposition(JSON.parse(await readFile5(file, "utf8")), values, baseDir), baseDir };
+}
+var byExtension = { ".mp4": "mp4", ".webm": "webm", ".mov": "mov", ".gif": "gif" };
+var formatForOutput = (output, fallback) => byExtension[extname3(output).toLowerCase()] ?? (extname3(output) === "" ? "png" : fallback);
+function checkRange(composition, range) {
+  const [first, last] = range ?? [0, composition.durationFrames - 1];
+  if (!Number.isInteger(first) || !Number.isInteger(last) || first < 0 || last < first || last >= composition.durationFrames) throw new Error(`Frame range must be whole frames within 0\u2013${composition.durationFrames - 1}, first \u2264 last; got ${first}\u2013${last}`);
+  return [first, last];
+}
+async function renderMedia(composition, options) {
+  const baseDir = options.baseDir ?? process.cwd(), output = resolve3(options.output);
+  const format = options.format ?? formatForOutput(output, composition.export.format);
+  const settings = exportSchema.parse({ ...composition.export, ...Object.fromEntries(Object.entries({ crf: options.crf, bitrate: options.bitrate, audioBitrate: options.audioBitrate, scale: options.scale, loudness: options.loudness }).filter(([, v]) => v !== void 0)), format, codec: options.codec ?? (format === "mp4" ? composition.export.codec : "h264"), transparent: options.transparent ?? composition.export.transparent });
+  const target = { ...composition, export: settings };
+  const [first, last] = checkRange(target, options.frameRange), total = last - first + 1, fps = target.fps;
+  const throwIfAborted = () => {
+    if (options.signal?.aborted) throw options.signal.reason ?? new Error("Render cancelled");
+  };
+  throwIfAborted();
+  await mkdir5(format === "png" ? output : dirname3(output), { recursive: true });
+  const renderer = await createRenderer(target, { baseDir, concurrency: options.concurrency ?? defaultConcurrency(), scale: settings.scale, motionBlur: options.motionBlur, allowCode: options.allowCode });
+  const audio = format === "png" || format === "gif" || options.audio === false ? void 0 : await masterAudio(target, baseDir).then((mix) => mix && { ...mix, durationSeconds: total / fps, offsetSeconds: first / fps });
+  const encoder = format === "png" ? void 0 : createEncoder(fps, output, audio, { format, codec: settings.codec, preset: options.preset ?? defaultPreset, transparent: settings.transparent, crf: settings.crf, bitrate: settings.bitrate, audioBitrate: settings.audioBitrate });
+  try {
+    let frame = first;
+    for await (const png of renderFrames(renderer, first, last + 1)) {
+      throwIfAborted();
+      if (encoder) await encoder.write(png);
+      else await writeFile5(join9(output, `frame-${String(frame).padStart(6, "0")}.png`), png);
+      frame++;
+      options.onProgress?.({ frame: frame - 1, rendered: frame - first, total });
+    }
+    await encoder?.finish();
+  } catch (error) {
+    encoder?.abort();
+    throw error;
+  } finally {
+    await renderer.close();
+  }
+  return { output, format, frames: total, durationSeconds: format === "png" ? total / fps : Number(await probe(output)) || total / fps };
+}
+async function renderStill(composition, options = {}) {
+  const frame = options.frame ?? 0;
+  checkRange(composition, [frame, frame]);
+  const target = options.transparent === void 0 ? composition : { ...composition, export: { ...composition.export, transparent: options.transparent } };
+  const renderer = await createRenderer(target, { baseDir: options.baseDir ?? process.cwd(), allowCode: options.allowCode });
+  try {
+    const png = await renderer.renderFrame(frame);
+    if (options.output) {
+      await mkdir5(dirname3(resolve3(options.output)), { recursive: true });
+      await writeFile5(resolve3(options.output), png);
+    }
+    return png;
+  } finally {
+    await renderer.close();
+  }
+}
+export {
+  VariableError,
+  absolutizeSources,
+  assetSchema,
+  attachCaptions,
+  audioWindows,
+  beatFunctions,
+  blendModes,
+  browserInstallHint,
+  builtinSoundName,
+  cacheRoot,
+  cacheUsage,
+  cameraSchema,
+  cameraState,
+  captionCueSchema,
+  captionKey,
+  captionLines,
+  captionTrack,
+  captionWordSchema,
+  checkFfmpeg,
+  cleanCache,
+  coerceVariable,
+  colorPattern,
+  colorProperties,
+  componentSchema,
+  componentsSchema,
+  compositionJsonSchema,
+  compositionSchema,
+  createRenderer,
+  cssVariableName,
+  defaultConcurrency,
+  defaultPreset,
+  describeBrowser,
+  describeError,
+  dropFillerWords,
+  duckSchema,
+  easingSchema,
+  evaluateFrame,
+  expandMattes,
+  expandSceneGrades,
+  exportSchema,
+  ffmpegPath,
+  ffprobePath,
+  formatCaptions,
+  formatForOutput,
+  frameToSeconds,
+  gradeLooks,
+  gradeSchema,
+  gradientSchema,
+  groupCaptionWords,
+  httpWorker,
+  interpolate,
+  isBuiltinSound,
+  launchBrowser,
+  layerSchema,
+  layerWindows,
+  listFieldSchema,
+  loadComposition,
+  loadCompositionFile,
+  masterAudio,
+  measureLoudness,
+  measureMedia,
+  measureMix,
+  outputFormats,
+  parseCaptions,
+  parseComposition,
+  planAudio,
+  planChunks,
+  prepareComposition,
+  renderDistributed,
+  renderFrames,
+  renderMedia,
+  renderStill,
+  requiredEncoders,
+  resolveVariables,
+  reviewComposition,
+  sceneSchema,
+  secondsToFrame,
+  sequenceScenes,
+  sfxFile,
+  sfxNames,
+  soundIntervals,
+  spanSchema,
+  splitCount,
+  splitPresetAnimations,
+  splitPresets,
+  splitSchema,
+  substituteVariables,
+  tempoSchema,
+  tokensMatch,
+  transitionSchema,
+  transitionState,
+  unitProperties,
+  variableSchema,
+  variablesSchema,
+  videoFrameIndex,
+  volumeEnvelope,
+  x264Presets
+};