reframe-video 0.1.1 → 0.1.3

package/dist/bin.js

@@ -10,16 +10,100 @@ var __export = (target, all) => {
 };
 
 // ../core/src/ir.ts
-var DEFAULT_TO_DURATION, DEFAULT_TWEEN_DURATION;
+var DEFAULT_TO_DURATION, DEFAULT_TWEEN_DURATION, DEFAULT_MOTIONPATH_DURATION;
 var init_ir = __esm({
   "../core/src/ir.ts"() {
     "use strict";
     DEFAULT_TO_DURATION = 0.5;
     DEFAULT_TWEEN_DURATION = 0.5;
+    DEFAULT_MOTIONPATH_DURATION = 1;
+  }
+});
+
+// ../core/src/path.ts
+function locate(segCount, u) {
+  if (segCount <= 0) return { i: 0, t: 0 };
+  const clamped = Math.max(0, Math.min(1, u));
+  const scaled = clamped * segCount;
+  let i = Math.floor(scaled);
+  if (i >= segCount) i = segCount - 1;
+  return { i, t: scaled - i };
+}
+function controls(points, closed, i) {
+  const n = points.length;
+  const at = (k) => {
+    if (closed) return points[(k % n + n) % n];
+    return points[Math.max(0, Math.min(n - 1, k))];
+  };
+  return [at(i - 1), at(i), at(i + 1), at(i + 2)];
+}
+function segCountOf(points, closed) {
+  const n = points.length;
+  if (n < 2) return 0;
+  return closed ? n : n - 1;
+}
+function pathPoint(points, closed, u) {
+  const n = points.length;
+  if (n === 0) return [0, 0];
+  if (n === 1) return [points[0][0], points[0][1]];
+  const segs = segCountOf(points, closed);
+  const { i, t } = locate(segs, u);
+  const [p0, p1, p2, p3] = controls(points, closed, i);
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const f = (a, b, c, d) => 0.5 * (2 * b + (-a + c) * t + (2 * a - 5 * b + 4 * c - d) * t2 + (-a + 3 * b - 3 * c + d) * t3);
+  return [f(p0[0], p1[0], p2[0], p3[0]), f(p0[1], p1[1], p2[1], p3[1])];
+}
+function pathTangentAngle(points, closed, u) {
+  const n = points.length;
+  if (n < 2) return 0;
+  const segs = segCountOf(points, closed);
+  const { i, t } = locate(segs, u);
+  const [p0, p1, p2, p3] = controls(points, closed, i);
+  const t2 = t * t;
+  const d = (a, b, c, e) => 0.5 * (-a + c + 2 * (2 * a - 5 * b + 4 * c - e) * t + 3 * (-a + 3 * b - 3 * c + e) * t2);
+  const dx = d(p0[0], p1[0], p2[0], p3[0]);
+  const dy = d(p0[1], p1[1], p2[1], p3[1]);
+  if (dx === 0 && dy === 0) return 0;
+  return Math.atan2(dy, dx) * 180 / Math.PI;
+}
+var init_path = __esm({
+  "../core/src/path.ts"() {
+    "use strict";
   }
 });
 
 // ../core/src/compile.ts
+function scaleTimeline(tl, k) {
+  switch (tl.kind) {
+    case "seq":
+    case "par":
+      return { ...tl, children: tl.children.map((c) => scaleTimeline(c, k)) };
+    case "stagger":
+      return { ...tl, interval: tl.interval * k, children: tl.children.map((c) => scaleTimeline(c, k)) };
+    case "wait":
+      return { ...tl, duration: tl.duration * k };
+    case "tween":
+      return { ...tl, duration: (tl.duration ?? DEFAULT_TWEEN_DURATION) * k };
+    case "motionPath":
+      return { ...tl, duration: (tl.duration ?? DEFAULT_MOTIONPATH_DURATION) * k };
+    case "to":
+      return {
+        ...tl,
+        duration: (tl.duration ?? DEFAULT_TO_DURATION) * k,
+        ...tl.stagger !== void 0 && { stagger: tl.stagger * k }
+      };
+    case "beat":
+      return {
+        ...tl,
+        children: tl.children.map((c) => scaleTimeline(c, k)),
+        ...tl.gap !== void 0 && { gap: tl.gap * k }
+      };
+  }
+}
+function orderBeats(children) {
+  return children.map((c, i) => ({ c, i, key: c.kind === "beat" && c.order !== void 0 ? c.order : i })).sort((a, b) => a.key - b.key || a.i - b.i).map((x) => x.c);
+}
 function compileScene(ir) {
   const nodeById = /* @__PURE__ */ new Map();
   const nodeOrder = [];
@@ -48,6 +132,7 @@ function compileScene(ir) {
     }
   }
   const segments = /* @__PURE__ */ new Map();
+  const motionPaths = /* @__PURE__ */ new Map();
   const current = new Map(initialValues);
   const pushSegment = (seg) => {
     const k = key(seg.target, seg.prop);
@@ -64,6 +149,50 @@ function compileScene(ir) {
     throw new Error(`cannot animate "${prop}" of "${target}": no base value to start from`);
   };
   const labelTimes = /* @__PURE__ */ new Map();
+  const beatTimes = /* @__PURE__ */ new Map();
+  const durationOf = (tl, start) => {
+    switch (tl.kind) {
+      case "seq": {
+        let t = start;
+        for (const child of orderBeats(tl.children)) t = durationOf(child, t);
+        return t;
+      }
+      case "par": {
+        let end = start;
+        for (const child of tl.children) end = Math.max(end, durationOf(child, start));
+        return end;
+      }
+      case "stagger": {
+        let end = start;
+        tl.children.forEach((child, i) => {
+          end = Math.max(end, durationOf(child, start + i * tl.interval));
+        });
+        return end;
+      }
+      case "wait":
+        return start + tl.duration;
+      case "tween":
+        return start + (tl.duration ?? DEFAULT_TWEEN_DURATION);
+      case "motionPath":
+        return start + (tl.duration ?? DEFAULT_MOTIONPATH_DURATION);
+      case "to": {
+        const override = ir.states?.[tl.state] ?? {};
+        const duration = tl.duration ?? DEFAULT_TO_DURATION;
+        const si = tl.stagger ?? 0;
+        const targets = nodeOrder.filter(
+          (id) => id in override && (tl.filter === void 0 || tl.filter.includes(id))
+        );
+        return start + duration + Math.max(0, targets.length - 1) * si;
+      }
+      case "beat": {
+        const grouping = { kind: tl.parallel ? "par" : "seq", children: tl.children };
+        const natural = durationOf(grouping, 0);
+        const k = tl.scale ?? (tl.duration !== void 0 ? tl.duration / Math.max(1e-9, natural) : 1);
+        const beatStart = tl.at ?? start + (tl.gap ?? 0);
+        return beatStart + k * natural;
+      }
+    }
+  };
   const walk = (tl, start) => {
     const end = walkInner(tl, start);
     if ("label" in tl && tl.label !== void 0) labelTimes.set(tl.label, { t0: start, t1: end });
@@ -73,9 +202,19 @@ function compileScene(ir) {
     switch (tl.kind) {
       case "seq": {
         let t = start;
-        for (const child of tl.children) t = walk(child, t);
+        for (const child of orderBeats(tl.children)) t = walk(child, t);
         return t;
       }
+      case "beat": {
+        const grouping = { kind: tl.parallel ? "par" : "seq", children: tl.children };
+        const k = tl.scale ?? (tl.duration !== void 0 ? tl.duration / Math.max(1e-9, durationOf(grouping, 0)) : 1);
+        const inner = k === 1 ? grouping : scaleTimeline(grouping, k);
+        const beatStart = tl.at ?? start + (tl.gap ?? 0);
+        const end = walk(inner, beatStart);
+        beatTimes.set(tl.name, { t0: beatStart, t1: end });
+        labelTimes.set(tl.name, { t0: beatStart, t1: end });
+        return end;
+      }
       case "par": {
         let end = start;
         for (const child of tl.children) end = Math.max(end, walk(child, start));
@@ -105,6 +244,23 @@ function compileScene(ir) {
         }
         return start + duration;
       }
+      case "motionPath": {
+        const duration = tl.duration ?? DEFAULT_MOTIONPATH_DURATION;
+        const points = tl.points;
+        const closed = tl.closed ?? false;
+        const autoRotate = tl.autoRotate ?? false;
+        const rotateOffset = tl.rotateOffset ?? 0;
+        let list = motionPaths.get(tl.target);
+        if (!list) motionPaths.set(tl.target, list = []);
+        list.push({ t0: start, t1: start + duration, points, closed, autoRotate, rotateOffset, ...tl.ease !== void 0 && { ease: tl.ease } });
+        if (points.length > 0) {
+          const [ex, ey] = pathPoint(points, closed, 1);
+          current.set(key(tl.target, "x"), ex);
+          current.set(key(tl.target, "y"), ey);
+          if (autoRotate) current.set(key(tl.target, "rotation"), pathTangentAngle(points, closed, 1) + rotateOffset);
+        }
+        return start + duration;
+      }
       case "to": {
         const override = ir.states?.[tl.state] ?? {};
         const duration = tl.duration ?? DEFAULT_TO_DURATION;
@@ -133,14 +289,17 @@ function compileScene(ir) {
   };
   const inferredEnd = ir.timeline ? walk(ir.timeline, 0) : 0;
   for (const list of segments.values()) list.sort((a, b) => a.t0 - b.t0);
+  for (const list of motionPaths.values()) list.sort((a, b) => a.t0 - b.t0);
   return {
     ir,
     duration: ir.duration ?? inferredEnd,
     segments,
+    motionPaths,
     initialValues,
     nodeById,
     nodeOrder,
-    labelTimes
+    labelTimes,
+    beatTimes
   };
 }
 var key;
@@ -148,6 +307,7 @@ var init_compile = __esm({
   "../core/src/compile.ts"() {
     "use strict";
     init_ir();
+    init_path();
     key = (target, prop) => `${target}.${prop}`;
   }
 });
@@ -195,11 +355,11 @@ function validateScene(ir) {
     );
   }
   const labels = /* @__PURE__ */ new Set();
-  const checkTimeline = (tl, path) => {
+  const checkTimeline = (tl, path2) => {
     if ("label" in tl && tl.label !== void 0) {
       if (labels.has(tl.label)) {
         problems.push(
-          `${path}: duplicate timeline label "${tl.label}" \u2014 labels are overlay addresses and must be unique`
+          `${path2}: duplicate timeline label "${tl.label}" \u2014 labels are overlay addresses and must be unique`
         );
       }
       labels.add(tl.label);
@@ -207,33 +367,63 @@ function validateScene(ir) {
     switch (tl.kind) {
       case "seq":
       case "par":
-        tl.children.forEach((c, i) => checkTimeline(c, `${path}.${tl.kind}[${i}]`));
+        tl.children.forEach((c, i) => checkTimeline(c, `${path2}.${tl.kind}[${i}]`));
         break;
       case "stagger":
-        if (tl.interval < 0) problems.push(`${path}: stagger interval must be >= 0`);
-        tl.children.forEach((c, i) => checkTimeline(c, `${path}.stagger[${i}]`));
+        if (tl.interval < 0) problems.push(`${path2}: stagger interval must be >= 0`);
+        tl.children.forEach((c, i) => checkTimeline(c, `${path2}.stagger[${i}]`));
         break;
       case "to":
         if (!(tl.state in states)) {
           problems.push(
-            `${path}: to("${tl.state}") references an undefined state \u2014 defined states: ${Object.keys(states).join(", ") || "(none)"}`
+            `${path2}: to("${tl.state}") references an undefined state \u2014 defined states: ${Object.keys(states).join(", ") || "(none)"}`
           );
         }
         if (tl.duration !== void 0 && tl.duration <= 0) {
-          problems.push(`${path}: to("${tl.state}") duration must be > 0`);
+          problems.push(`${path2}: to("${tl.state}") duration must be > 0`);
         }
         for (const id of tl.filter ?? []) {
-          if (!nodeById.has(id)) problems.push(`${path}: filter contains unknown node "${id}"`);
+          if (!nodeById.has(id)) problems.push(`${path2}: filter contains unknown node "${id}"`);
         }
         break;
       case "tween":
-        checkProps(path, tl.target, tl.props);
+        checkProps(path2, tl.target, tl.props);
         if (tl.duration !== void 0 && tl.duration <= 0) {
-          problems.push(`${path}: tween duration must be > 0`);
+          problems.push(`${path2}: tween duration must be > 0`);
         }
         break;
+      case "motionPath": {
+        const node = nodeById.get(tl.target);
+        if (!node) {
+          problems.push(
+            `${path2}: motionPath targets unknown node "${tl.target}" \u2014 known ids: ${[...nodeById.keys()].join(", ")}`
+          );
+        } else if (node.type === "line") {
+          problems.push(`${path2}: motionPath cannot target a line (no x/y) \u2014 "${tl.target}"`);
+        }
+        if (tl.points.length < 1) problems.push(`${path2}: motionPath "${tl.target}" needs at least 1 point`);
+        if (tl.duration !== void 0 && tl.duration <= 0) {
+          problems.push(`${path2}: motionPath "${tl.target}" duration must be > 0`);
+        }
+        break;
+      }
       case "wait":
-        if (tl.duration < 0) problems.push(`${path}: wait duration must be >= 0`);
+        if (tl.duration < 0) problems.push(`${path2}: wait duration must be >= 0`);
+        break;
+      case "beat":
+        if (labels.has(tl.name)) {
+          problems.push(
+            `${path2}: duplicate timeline label "${tl.name}" (beat name) \u2014 labels are overlay addresses and must be unique`
+          );
+        }
+        labels.add(tl.name);
+        if (tl.duration !== void 0 && tl.duration <= 0) {
+          problems.push(`${path2}: beat "${tl.name}" duration must be > 0`);
+        }
+        if (tl.scale !== void 0 && tl.scale <= 0) {
+          problems.push(`${path2}: beat "${tl.name}" scale must be > 0`);
+        }
+        tl.children.forEach((c, i) => checkTimeline(c, `${path2}.beat(${tl.name})[${i}]`));
         break;
     }
   };
@@ -284,6 +474,7 @@ var init_validate = __esm({
       line: ["x1", "y1", "x2", "y2", "stroke", "strokeWidth", "opacity", "progress"],
       text: [...COMMON_PROPS, "content", "contentDecimals", "fontFamily", "fontSize", "fontWeight", "fill", "letterSpacing"],
       image: [...COMMON_PROPS, "src", "width", "height"],
+      path: [...COMMON_PROPS, "d", "fill", "stroke", "strokeWidth", "progress", "originX", "originY"],
       group: COMMON_PROPS
     };
     SceneValidationError = class extends Error {
@@ -299,6 +490,51 @@ ${problems.map((p) => `  - ${p}`).join("\n")}`);
 });
 
 // ../core/src/dsl.ts
+function scene(input) {
+  const ir = { version: 1, ...input };
+  validateScene(ir);
+  if (ir.duration === void 0 && ir.timeline) {
+    ir.duration = compileScene(ir).duration;
+  }
+  return ir;
+}
+function rect(props) {
+  const { id, ...rest } = props;
+  return { type: "rect", id, props: rest };
+}
+function text(props) {
+  const { id, ...rest } = props;
+  return { type: "text", id, props: rest };
+}
+function path(props) {
+  const { id, ...rest } = props;
+  return { type: "path", id, props: rest };
+}
+function group(props, children) {
+  const { id, ...rest } = props;
+  return { type: "group", id, props: rest, children };
+}
+function seq(...children) {
+  return { kind: "seq", children };
+}
+function par(...children) {
+  return { kind: "par", children };
+}
+function stagger(interval, ...children) {
+  return { kind: "stagger", interval, children };
+}
+function beat(name, opts, children) {
+  return { kind: "beat", name, children, ...opts };
+}
+function tween(target, props, opts = {}) {
+  return { kind: "tween", target, props, ...opts };
+}
+function wait(duration, label) {
+  return { kind: "wait", duration, ...label !== void 0 && { label } };
+}
+function motionPath(target, points, opts = {}) {
+  return { kind: "motionPath", target, points, ...opts };
+}
 var init_dsl = __esm({
   "../core/src/dsl.ts"() {
     "use strict";
@@ -430,13 +666,16 @@ function applyOverlay(ir, overlay, layer, report) {
     const byLabel = /* @__PURE__ */ new Map();
     const walkTimeline = (tl) => {
       if ("label" in tl && tl.label !== void 0) byLabel.set(tl.label, tl);
+      if (tl.kind === "beat") byLabel.set(tl.name, tl);
       if ("children" in tl) tl.children.forEach(walkTimeline);
     };
     if (ir.timeline) walkTimeline(ir.timeline);
     const PATCHABLE = {
       to: ["duration", "ease", "stagger"],
       tween: ["duration", "ease"],
-      wait: ["duration"]
+      wait: ["duration"],
+      motionPath: ["points", "duration", "ease"],
+      beat: ["at", "gap", "scale", "duration", "order"]
     };
     let timingPatched = false;
     for (const [label, patch] of Object.entries(overlay.timeline)) {
@@ -460,7 +699,7 @@ function applyOverlay(ir, overlay, layer, report) {
         }
         step[key2] = value;
         applied(`timeline.${label}.${key2}`, "set");
-        if (key2 === "duration" || key2 === "stagger") timingPatched = true;
+        if (["duration", "stagger", "at", "gap", "scale", "order"].includes(key2)) timingPatched = true;
       }
     }
     if (timingPatched && overlay.scene?.duration === void 0) {
@@ -484,6 +723,185 @@ var init_compose = __esm({
   }
 });
 
+// ../core/src/presets.ts
+function makeRng(seed) {
+  let a = seed >>> 0 || 2654435769;
+  return () => {
+    a = a + 1831565813 | 0;
+    let t = Math.imul(a ^ a >>> 15, 1 | a);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function ctx(o) {
+  const rand = makeRng((o.seed ?? 0) + 1);
+  return {
+    e: clamp01(o.energy ?? 0.5),
+    sp: Math.max(0.25, o.speed ?? 1),
+    it: clamp01(o.intensity ?? 0.5),
+    from: o.from,
+    rand,
+    jit: (amp) => (rand() - 0.5) * 2 * amp,
+    g: o.target.group,
+    cx: o.target.center[0],
+    cy: o.target.center[1],
+    s: o.target.baseScale,
+    fills: o.target.fills,
+    inks: o.target.inks
+  };
+}
+function settleEase(e) {
+  return e < 0.34 ? "easeOutCubic" : e < 0.67 ? "easeOutBack" : "easeOutElastic";
+}
+function fromVec(from, dist) {
+  switch (from) {
+    case "left":
+      return [-dist, 0];
+    case "right":
+      return [dist, 0];
+    case "top":
+      return [0, -dist];
+    default:
+      return [0, dist];
+  }
+}
+function fadeFills(c, base = 0.4, gap = 0.06) {
+  return stagger(
+    gap / c.sp,
+    ...c.fills.map(
+      (id, i) => tween(id, { opacity: 1 }, { duration: dur(base, c.sp), ease: "easeOutQuad", ...i === 0 && { label: "reveal" } })
+    )
+  );
+}
+function drawInks(c) {
+  return stagger(
+    0.15 / c.sp,
+    ...c.inks.map(
+      (id, i) => tween(id, { progress: 1 }, { duration: dur(1.3 + c.jit(0.2), c.sp), ease: "easeInOutQuad", ...i === 0 && { label: "draw" } })
+    )
+  );
+}
+function motionPreset(name, opts) {
+  const c = ctx(opts);
+  switch (name) {
+    case "draw-bloom":
+      return beat("draw-bloom", {}, [
+        drawInks(c),
+        fadeFills(c, 0.45),
+        tween(c.g, { scale: c.s * (1.02 + 0.05 * c.e) }, { duration: dur(2.4, c.sp), ease: "easeInOutQuad", label: "settle" })
+      ]);
+    case "punch-in": {
+      const peak = c.s * (1 + 0.06 + 0.24 * c.e + c.jit(0.02));
+      return beat("punch-in", {}, [
+        par(
+          fadeFills(c, 0.25),
+          seq(
+            tween(c.g, { scale: peak }, { duration: dur(0.45 + c.jit(0.05), c.sp), ease: "easeOutCubic", label: "punch" }),
+            tween(c.g, { scale: c.s }, { duration: dur(0.5, c.sp), ease: settleEase(c.e) })
+          )
+        )
+      ]);
+    }
+    case "rise-settle": {
+      const es = 0.65 + c.rand() * 0.7;
+      const dist = (220 + 260 * c.it) * es;
+      const [dx, dy] = fromVec(c.from ?? "bottom", dist);
+      const jx = c.jit(110);
+      return beat("rise-settle", {}, [
+        par(
+          motionPath(
+            c.g,
+            [
+              [c.cx + dx + jx, c.cy + dy],
+              [c.cx + dx * 0.4 - jx * 0.6, c.cy + dy * 0.4],
+              [c.cx, c.cy]
+            ],
+            { duration: dur(1.1, c.sp), ease: settleEase(c.e), label: "rise" }
+          ),
+          fadeFills(c, 0.4)
+        )
+      ]);
+    }
+    case "slide-bank": {
+      const es = 0.65 + c.rand() * 0.7;
+      const dist = (420 + 240 * c.it) * es;
+      const [dx, dy] = fromVec(c.from ?? "left", dist);
+      const arc = c.jit(140);
+      const midx = c.jit(120);
+      const move = dur(1.2, c.sp);
+      return beat("slide-bank", {}, [
+        par(
+          motionPath(
+            c.g,
+            [
+              [c.cx + dx, c.cy + dy],
+              [c.cx + dx * 0.4 + midx, c.cy + dy * 0.4 - 70 - arc],
+              [c.cx, c.cy]
+            ],
+            { duration: move, ease: settleEase(c.e), autoRotate: true, label: "slide" }
+          ),
+          // level the bank out once it lands (authored after the path → wins for rotation)
+          seq(wait(move), tween(c.g, { rotation: 0 }, { duration: dur(0.5, c.sp), ease: "easeOutCubic" })),
+          fadeFills(c, 0.4)
+        )
+      ]);
+    }
+    case "reveal-orbit": {
+      const es = 0.65 + c.rand() * 0.7;
+      const orbit = (180 + 160 * c.it) * es;
+      const jx = c.jit(0.4);
+      const jy = c.jit(0.4);
+      return beat("reveal-orbit", {}, [
+        drawInks(c),
+        fadeFills(c, 0.45),
+        par(
+          motionPath(
+            c.g,
+            [
+              [c.cx, c.cy],
+              [c.cx - orbit * (1 + jx), c.cy - orbit * 0.8],
+              [c.cx + orbit * (1 + jy), c.cy - orbit],
+              [c.cx, c.cy]
+            ],
+            { duration: dur(1.7, c.sp), ease: "easeInOutCubic", label: "orbit" }
+          ),
+          seq(
+            tween(c.g, { scale: c.s * (1.12 + 0.1 * c.e) }, { duration: dur(0.85, c.sp), ease: "easeOutBack" }),
+            tween(c.g, { scale: c.s }, { duration: dur(0.85, c.sp), ease: "easeInOutQuad" })
+          )
+        )
+      ]);
+    }
+    case "spin-forge": {
+      const turns = 1 + Math.round(c.it);
+      const dir = c.rand() < 0.5 ? -1 : 1;
+      const startRot = dir * 360 * turns;
+      const peak = c.s * (1 + 0.05 + 0.2 * c.e);
+      return beat("spin-forge", {}, [
+        par(
+          seq(
+            tween(c.g, { scale: c.s * 0.2, rotation: startRot }, { duration: SET }),
+            // establish (invisible)
+            tween(c.g, { scale: peak, rotation: 0 }, { duration: dur(0.9, c.sp), ease: "easeOutBack", label: "spin" }),
+            tween(c.g, { scale: c.s }, { duration: dur(0.3, c.sp), ease: "easeInOutQuad" })
+          ),
+          seq(wait(SET), fadeFills(c, 0.3))
+        )
+      ]);
+    }
+  }
+}
+var clamp01, SET, dur;
+var init_presets = __esm({
+  "../core/src/presets.ts"() {
+    "use strict";
+    init_dsl();
+    clamp01 = (x) => Math.max(0, Math.min(1, x));
+    SET = 1 / 120;
+    dur = (base, sp) => base / sp;
+  }
+});
+
 // ../core/src/audio.ts
 function resolveAudioPlan(compiled) {
   const audio = compiled.ir.audio;
@@ -569,10 +987,23 @@ var init_behaviors = __esm({
 });
 
 // ../core/src/interpolate.ts
-var EASE_TABLE, EASE_NAMES;
+function easeOutBounce(u) {
+  const n1 = 7.5625;
+  const d1 = 2.75;
+  if (u < 1 / d1) return n1 * u * u;
+  if (u < 2 / d1) return n1 * (u -= 1.5 / d1) * u + 0.75;
+  if (u < 2.5 / d1) return n1 * (u -= 2.25 / d1) * u + 0.9375;
+  return n1 * (u -= 2.625 / d1) * u + 0.984375;
+}
+var BACK_C1, BACK_C2, BACK_C3, ELASTIC_C4, ELASTIC_C5, EASE_TABLE, EASE_NAMES;
 var init_interpolate = __esm({
   "../core/src/interpolate.ts"() {
     "use strict";
+    BACK_C1 = 1.70158;
+    BACK_C2 = BACK_C1 * 1.525;
+    BACK_C3 = BACK_C1 + 1;
+    ELASTIC_C4 = 2 * Math.PI / 3;
+    ELASTIC_C5 = 2 * Math.PI / 4.5;
     EASE_TABLE = {
       linear: (u) => u,
       easeInQuad: (u) => u * u,
@@ -586,7 +1017,20 @@ var init_interpolate = __esm({
       easeInOutQuart: (u) => u < 0.5 ? 8 * u ** 4 : 1 - (-2 * u + 2) ** 4 / 2,
       easeInExpo: (u) => u === 0 ? 0 : 2 ** (10 * u - 10),
       easeOutExpo: (u) => u === 1 ? 1 : 1 - 2 ** (-10 * u),
-      easeInOutExpo: (u) => u === 0 ? 0 : u === 1 ? 1 : u < 0.5 ? 2 ** (20 * u - 10) / 2 : (2 - 2 ** (-20 * u + 10)) / 2
+      easeInOutExpo: (u) => u === 0 ? 0 : u === 1 ? 1 : u < 0.5 ? 2 ** (20 * u - 10) / 2 : (2 - 2 ** (-20 * u + 10)) / 2,
+      // --- expressive eases (GSAP's signature feel) — standard Penner equations ---
+      // back: overshoots past the target then settles (pop / snap)
+      easeInBack: (u) => BACK_C3 * u ** 3 - BACK_C1 * u * u,
+      easeOutBack: (u) => 1 + BACK_C3 * (u - 1) ** 3 + BACK_C1 * (u - 1) ** 2,
+      easeInOutBack: (u) => u < 0.5 ? (2 * u) ** 2 * ((BACK_C2 + 1) * 2 * u - BACK_C2) / 2 : ((2 * u - 2) ** 2 * ((BACK_C2 + 1) * (2 * u - 2) + BACK_C2) + 2) / 2,
+      // elastic: rings around the target before settling (playful spring)
+      easeInElastic: (u) => u === 0 ? 0 : u === 1 ? 1 : -(2 ** (10 * u - 10)) * Math.sin((u * 10 - 10.75) * ELASTIC_C4),
+      easeOutElastic: (u) => u === 0 ? 0 : u === 1 ? 1 : 2 ** (-10 * u) * Math.sin((u * 10 - 0.75) * ELASTIC_C4) + 1,
+      easeInOutElastic: (u) => u === 0 ? 0 : u === 1 ? 1 : u < 0.5 ? -(2 ** (20 * u - 10) * Math.sin((20 * u - 11.125) * ELASTIC_C5)) / 2 : 2 ** (-20 * u + 10) * Math.sin((20 * u - 11.125) * ELASTIC_C5) / 2 + 1,
+      // bounce: drops and bounces to rest (lands without overshoot)
+      easeInBounce: (u) => 1 - easeOutBounce(1 - u),
+      easeOutBounce,
+      easeInOutBounce: (u) => u < 0.5 ? (1 - easeOutBounce(1 - 2 * u)) / 2 : (1 + easeOutBounce(2 * u - 1)) / 2
     };
     EASE_NAMES = Object.keys(EASE_TABLE);
   }
@@ -598,6 +1042,7 @@ var init_evaluate = __esm({
     "use strict";
     init_behaviors();
     init_interpolate();
+    init_path();
   }
 });
 
@@ -638,6 +1083,14 @@ var init_assets = __esm({
   }
 });
 
+// ../core/src/motion.ts
+var init_motion = __esm({
+  "../core/src/motion.ts"() {
+    "use strict";
+    init_dsl();
+  }
+});
+
 // ../core/src/index.ts
 var init_src = __esm({
   "../core/src/index.ts"() {
@@ -647,11 +1100,160 @@ var init_src = __esm({
     init_validate();
     init_compose();
     init_compile();
+    init_path();
+    init_presets();
     init_audio();
     init_evaluate();
     init_interpolate();
     init_behaviors();
     init_assets();
+    init_motion();
+  }
+});
+
+// ../render-cli/src/logoSting.ts
+var logoSting_exports = {};
+__export(logoSting_exports, {
+  LOGO_PRESETS: () => LOGO_PRESETS,
+  buildLogoSting: () => buildLogoSting,
+  resolveLogo: () => resolveLogo
+});
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+async function loadSvg(arg) {
+  if (existsSync(arg)) {
+    return { svg: await readFile(arg, "utf8"), name: arg.split("/").pop().replace(/\.svg$/i, "") };
+  }
+  const slug = arg.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const r = await fetch(`https://cdn.simpleicons.org/${slug}`);
+  if (!r.ok) throw new Error(`no local file "${arg}", and simple-icons has no "${slug}" (${r.status})`);
+  return { svg: await r.text(), name: arg };
+}
+function tooDark(hex) {
+  const h = hex.replace("#", "");
+  const n = h.length === 3 ? h.split("").map((c) => c + c).join("") : h;
+  const r = parseInt(n.slice(0, 2), 16);
+  const g = parseInt(n.slice(2, 4), 16);
+  const b = parseInt(n.slice(4, 6), 16);
+  return 0.299 * r + 0.587 * g + 0.114 * b < 40;
+}
+function parseSvg(svg) {
+  let viewBox = { minX: 0, minY: 0, w: 100, h: 100 };
+  const vb = svg.match(/viewBox\s*=\s*"([\d.\-\s]+)"/i);
+  if (vb) {
+    const [a, b, c, d] = vb[1].trim().split(/\s+/).map(Number);
+    viewBox = { minX: a, minY: b, w: c, h: d };
+  } else {
+    const w = svg.match(/\bwidth\s*=\s*"([\d.]+)/i);
+    const h = svg.match(/\bheight\s*=\s*"([\d.]+)/i);
+    if (w && h) viewBox = { minX: 0, minY: 0, w: +w[1], h: +h[1] };
+  }
+  const rootFill = svg.match(/<svg[^>]*\bfill\s*=\s*"(#[0-9a-fA-F]{3,8})"/)?.[1];
+  const fallback = rootFill && !tooDark(rootFill) ? rootFill : "#E6EDF3";
+  const paths = [];
+  const re = /<path\b[^>]*>/g;
+  let m;
+  while (m = re.exec(svg)) {
+    const tag = m[0];
+    const d = tag.match(/\bd\s*=\s*"([^"]+)"/)?.[1];
+    if (!d) continue;
+    let fill = tag.match(/\bfill\s*=\s*"(#[0-9a-fA-F]{3,8})"/)?.[1] ?? fallback;
+    if (tooDark(fill)) fill = fallback;
+    paths.push({ d, fill });
+  }
+  return { paths, viewBox };
+}
+async function resolveLogo(arg, displayName, opts) {
+  if (opts.motion && !LOGO_PRESETS.includes(opts.motion)) {
+    throw new Error(`unknown --motion "${opts.motion}". options: ${LOGO_PRESETS.join(", ")}`);
+  }
+  const { svg, name } = await loadSvg(arg);
+  const { paths, viewBox } = parseSvg(svg);
+  if (paths.length === 0) throw new Error("no <path> elements found \u2014 logo stings need a path-based SVG");
+  const from = FROMS.includes(opts.from) ? opts.from : void 0;
+  const data = {
+    name: displayName ?? titleCase(name),
+    paths,
+    viewBox,
+    ...opts.motion && { motion: opts.motion },
+    ...opts.energy !== void 0 && { energy: opts.energy },
+    ...opts.speed !== void 0 && { speed: opts.speed },
+    ...opts.intensity !== void 0 && { intensity: opts.intensity },
+    ...from && { from },
+    ...opts.seed !== void 0 && { seed: opts.seed }
+  };
+  const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "logo";
+  return { data, slug };
+}
+function buildLogoSting(d) {
+  const W = 1080;
+  const H = 1080;
+  const CX = 540;
+  const CY = 500;
+  const vcx = d.viewBox.minX + d.viewBox.w / 2;
+  const vcy = d.viewBox.minY + d.viewBox.h / 2;
+  const fit = LOGO_PX / Math.max(d.viewBox.w, d.viewBox.h);
+  const sw = 2.2 / fit;
+  const fills = d.paths.map(
+    (p, i) => path({ id: `fill-${i}`, d: p.d, originX: vcx, originY: vcy, x: 0, y: 0, fill: p.fill, opacity: 0 })
+  );
+  const inks = d.paths.map(
+    (p, i) => path({ id: `ink-${i}`, d: p.d, originX: vcx, originY: vcy, x: 0, y: 0, stroke: p.fill, strokeWidth: sw, progress: 0 })
+  );
+  const rig = {
+    group: "logo",
+    center: [CX, CY],
+    baseScale: fit,
+    fills: fills.map((n) => n.id),
+    inks: inks.map((n) => n.id)
+  };
+  return scene({
+    id: "logo-sting",
+    size: { width: W, height: H },
+    fps: 30,
+    background: BG,
+    nodes: [
+      rect({ id: "bg", x: 0, y: 0, width: W, height: H, fill: BG }),
+      group({ id: "logo", x: CX, y: CY, scale: fit }, [...fills, ...inks]),
+      text({ id: "word", x: CX, y: 905, anchor: "center", content: d.name, fontFamily: "Inter", fontSize: 56, fontWeight: 800, fill: FG, opacity: 0 }),
+      text({ id: "made", x: CX, y: 968, anchor: "center", content: "made with reframe", fontFamily: "Inter", fontSize: 20, fill: MUTED, opacity: 0 })
+    ],
+    timeline: seq(
+      motionPreset(d.motion ?? "reveal-orbit", {
+        target: rig,
+        ...d.energy !== void 0 && { energy: d.energy },
+        ...d.speed !== void 0 && { speed: d.speed },
+        ...d.intensity !== void 0 && { intensity: d.intensity },
+        ...d.from !== void 0 && { from: d.from },
+        ...d.seed !== void 0 && { seed: d.seed }
+      }),
+      par(
+        tween("word", { opacity: 1 }, { duration: 0.5, ease: "easeOutQuad", label: "word" }),
+        seq(wait(0.2), tween("made", { opacity: 1 }, { duration: 0.5, ease: "easeOutQuad" }))
+      ),
+      wait(0.8, "hold")
+    )
+  });
+}
+var LOGO_PRESETS, titleCase, FROMS, BG, FG, MUTED, LOGO_PX;
+var init_logoSting = __esm({
+  "../render-cli/src/logoSting.ts"() {
+    "use strict";
+    init_src();
+    LOGO_PRESETS = [
+      "draw-bloom",
+      "punch-in",
+      "rise-settle",
+      "slide-bank",
+      "reveal-orbit",
+      "spin-forge"
+    ];
+    titleCase = (s) => s.replace(/[-_]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+    FROMS = ["left", "right", "top", "bottom"];
+    BG = "#0D1117";
+    FG = "#E6EDF3";
+    MUTED = "#8B949E";
+    LOGO_PX = 520;
   }
 });
 
@@ -699,52 +1301,52 @@ function buffer(duration) {
   return { out: new Float32Array(n), n };
 }
 function whoosh(seed) {
-  const dur = 0.35;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.35;
+  const { out, n } = buffer(dur2);
   let lp = 0;
   let lp2 = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const u = t / dur;
+    const u = t / dur2;
     const center = 1200 * Math.pow(300 / 1200, u);
     const alpha = Math.min(1, TAU * center / SAMPLE_RATE);
     lp += alpha * (noise(i, seed) - lp);
     lp2 += alpha * 0.5 * (lp - lp2);
-    const env = u < 0.3 ? u / 0.3 : expDecay(t - 0.3 * dur, dur * 0.7, 4);
+    const env = u < 0.3 ? u / 0.3 : expDecay(t - 0.3 * dur2, dur2 * 0.7, 4);
     out[i] = (lp - lp2) * env * 2.2;
   }
   return out;
 }
 function pop(seed) {
-  const dur = 0.12;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.12;
+  const { out, n } = buffer(dur2);
   let phase = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
     const freq = 600 * Math.pow(150 / 600, t / 0.08);
     phase += TAU * freq / SAMPLE_RATE;
     const transient = t < 2e-3 ? noise(i, seed) * 0.5 : 0;
-    out[i] = (Math.sin(phase) + transient) * expDecay(t, dur, 6) * 0.8;
+    out[i] = (Math.sin(phase) + transient) * expDecay(t, dur2, 6) * 0.8;
   }
   return out;
 }
 function tick(seed) {
-  const dur = 0.03;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.03;
+  const { out, n } = buffer(dur2);
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
     const sine = t < 4e-3 ? Math.sin(TAU * 4e3 * t) : 0;
-    out[i] = (sine * 0.6 + noise(i, seed) * 0.35) * expDecay(t, dur, 8);
+    out[i] = (sine * 0.6 + noise(i, seed) * 0.35) * expDecay(t, dur2, 8);
   }
   return out;
 }
 function rise(seed) {
-  const dur = 0.5;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.5;
+  const { out, n } = buffer(dur2);
   let phase = 0;
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const u = t / dur;
+    const u = t / dur2;
     const freq = 220 * Math.pow(880 / 220, u);
     phase += TAU * freq / SAMPLE_RATE;
     const env = Math.sin(Math.PI * Math.min(1, u * 1.05)) ** 1.5;
@@ -753,8 +1355,8 @@ function rise(seed) {
   return out;
 }
 function shimmer(seed) {
-  const dur = 0.9;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.9;
+  const { out, n } = buffer(dur2);
   const partials = Array.from({ length: 5 }, (_, p) => ({
     freq: 2e3 + hash01(p, seed + 7) * 2e3,
     am: 0.5 + hash01(p, seed + 8) * 1.5,
@@ -762,7 +1364,7 @@ function shimmer(seed) {
   }));
   for (let i = 0; i < n; i++) {
     const t = i / SAMPLE_RATE;
-    const u = t / dur;
+    const u = t / dur2;
     const env = Math.sin(Math.PI * u) ** 1.2;
     let s = 0;
     for (const part of partials) {
@@ -773,8 +1375,8 @@ function shimmer(seed) {
   return out;
 }
 function thud(seed) {
-  const dur = 0.25;
-  const { out, n } = buffer(dur);
+  const dur2 = 0.25;
+  const { out, n } = buffer(dur2);
   let phase = 0;
   let lp = 0;
   for (let i = 0; i < n; i++) {
@@ -783,7 +1385,7 @@ function thud(seed) {
     phase += TAU * freq / SAMPLE_RATE;
     lp += 0.02 * (noise(i, seed) - lp);
     const attack = t < 0.01 ? lp * 3 : 0;
-    out[i] = (Math.sin(phase) * 0.9 + attack) * expDecay(t, dur, 5);
+    out[i] = (Math.sin(phase) * 0.9 + attack) * expDecay(t, dur2, 5);
   }
   return out;
 }
@@ -818,7 +1420,7 @@ var init_synth = __esm({
     init_wav();
     noise = (n, seed) => hash01(n, seed) * 2 - 1;
     TAU = Math.PI * 2;
-    expDecay = (t, dur, k = 5) => Math.exp(-k * t / dur);
+    expDecay = (t, dur2, k = 5) => Math.exp(-k * t / dur2);
     RECIPES = {
       whoosh,
       pop,
@@ -832,26 +1434,26 @@ var init_synth = __esm({
 
 // ../render-cli/src/audio/sfx.ts
 import { mkdir, rename, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { existsSync as existsSync2 } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-function fnv1a(text) {
+function fnv1a(text2) {
   let h = 2166136261;
-  for (let i = 0; i < text.length; i++) {
-    h ^= text.charCodeAt(i);
+  for (let i = 0; i < text2.length; i++) {
+    h ^= text2.charCodeAt(i);
     h = Math.imul(h, 16777619);
   }
   return (h >>> 0).toString(16);
 }
 async function writeCached(key2, make) {
-  const path = join(CACHE, `${key2}.wav`);
-  if (existsSync(path)) return path;
+  const path2 = join(CACHE, `${key2}.wav`);
+  if (existsSync2(path2)) return path2;
   await mkdir(CACHE, { recursive: true });
-  const temp = `${path}.${process.pid}.${fnv1a(String(performance.now()))}.tmp`;
+  const temp = `${path2}.${process.pid}.${fnv1a(String(performance.now()))}.tmp`;
   await writeFile(temp, encodeWavMono16(make()));
-  await rename(temp, path);
-  return path;
+  await rename(temp, path2);
+  return path2;
 }
 async function resolveCueFile(cue, sceneDir) {
   if (cue.source.kind === "file") {
@@ -861,14 +1463,14 @@ async function resolveCueFile(cue, sceneDir) {
       resolve(sceneDir, p),
       join(VENDORED, p)
     ]) {
-      if (candidate && existsSync(candidate)) return candidate;
+      if (candidate && existsSync2(candidate)) return candidate;
     }
     throw new Error(
       `audio cue file "${p}" not found (tried absolute, scene-relative, assets/sfx/)`
     );
   }
   const vendored = join(VENDORED, `${cue.source.name}.wav`);
-  if (existsSync(vendored)) return vendored;
+  if (existsSync2(vendored)) return vendored;
   const { name, params } = cue.source;
   return writeCached(`${name}-${fnv1a(JSON.stringify(params))}`, () => synthSfx(name, params));
 }
@@ -876,7 +1478,7 @@ async function resolveBgmFile(source, duration, sceneDir) {
   if (source.kind === "file") {
     const p = source.path;
     for (const candidate of [isAbsolute(p) ? p : null, resolve(sceneDir, p), join(VENDORED, p)]) {
-      if (candidate && existsSync(candidate)) return candidate;
+      if (candidate && existsSync2(candidate)) return candidate;
     }
     throw new Error(`bgm file "${p}" not found`);
   }
@@ -1046,14 +1648,14 @@ var init_encode = __esm({
 });
 
 // ../render-cli/src/fonts.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile2 } from "node:fs/promises";
 import { dirname as dirname3, join as join3 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 async function fontFaceCss() {
   if (cssCache) return cssCache;
   const rules = await Promise.all(
     WEIGHTS.map(async (weight) => {
-      const data = await readFile(join3(FONTS_DIR, `inter-${weight}.woff2`));
+      const data = await readFile2(join3(FONTS_DIR, `inter-${weight}.woff2`));
       return `@font-face {
   font-family: "Inter";
   font-style: normal;
@@ -1076,8 +1678,8 @@ var init_fonts = __esm({
 });
 
 // ../render-cli/src/images.ts
-import { readFile as readFile2 } from "node:fs/promises";
-import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
 import { extname, isAbsolute as isAbsolute2, resolve as resolve2 } from "node:path";
 async function buildImageAssets(ir, sceneDir) {
   const assets = {};
@@ -1091,11 +1693,11 @@ async function buildImageAssets(ir, sceneDir) {
     const candidates = [isAbsolute2(src) ? src : null, resolve2(sceneDir, src)].filter(
       (c) => c !== null
     );
-    const found = candidates.find((c) => existsSync2(c));
+    const found = candidates.find((c) => existsSync3(c));
     if (!found) {
       throw new Error(`image "${src}" not found (tried: ${candidates.join(", ")})`);
     }
-    const data = await readFile2(found);
+    const data = await readFile3(found);
     assets[src] = `data:${mime};base64,${data.toString("base64")}`;
   }
   return assets;
@@ -1219,8 +1821,8 @@ async function withPage(size, fn) {
 async function browserBundle() {
   if (bundleCache) return bundleCache;
   if (true) {
-    const { readFile: readFile5 } = await import("node:fs/promises");
-    bundleCache = await readFile5(
+    const { readFile: readFile6 } = await import("node:fs/promises");
+    bundleCache = await readFile6(
       join4(dirname4(fileURLToPath3(import.meta.url)), "browserEntry.js"),
       "utf8"
     );
@@ -1282,7 +1884,7 @@ __export(batch_exports, {
   parseCsv: () => parseCsv,
   runBatch: () => runBatch
 });
-import { mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile3, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir3, mkdtemp as mkdtemp2, readFile as readFile4, rm as rm2, writeFile as writeFile4 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join5, dirname as dirname5 } from "node:path";
 function overlayFromFlat(row, name) {
@@ -1321,8 +1923,8 @@ function overlayFromFlat(row, name) {
   }
   return doc;
 }
-function parseCsv(text) {
-  const lines = text.split(/\r?\n/).filter((l) => l.trim().length > 0);
+function parseCsv(text2) {
+  const lines = text2.split(/\r?\n/).filter((l) => l.trim().length > 0);
   if (lines.length < 2) return [];
   const split = (line) => {
     const out = [];
@@ -1357,14 +1959,14 @@ function parseCsv(text) {
     return row;
   });
 }
-async function loadRows(path) {
-  const text = await readFile3(path, "utf8");
-  if (path.endsWith(".csv")) return parseCsv(text);
-  const parsed = JSON.parse(text);
-  if (!Array.isArray(parsed)) throw new Error(`${path}: expected a JSON array of row objects`);
+async function loadRows(path2) {
+  const text2 = await readFile4(path2, "utf8");
+  if (path2.endsWith(".csv")) return parseCsv(text2);
+  const parsed = JSON.parse(text2);
+  if (!Array.isArray(parsed)) throw new Error(`${path2}: expected a JSON array of row objects`);
   return parsed;
 }
-async function runBatch(scene, rows, opts) {
+async function runBatch(scene2, rows, opts) {
   await mkdir3(opts.outDir, { recursive: true });
   const results = new Array(rows.length);
   let next = 0;
@@ -1377,7 +1979,7 @@ async function runBatch(scene, rows, opts) {
       let result;
       try {
         const rowOverlay = overlayFromFlat(row, name);
-        const { ir, report } = composeScene(scene, ...opts.baseOverlays, rowOverlay);
+        const { ir, report } = composeScene(scene2, ...opts.baseOverlays, rowOverlay);
         const framesDir = await mkdtemp2(join5(tmpdir3(), `reframe-batch-${index}-`));
         const output = join5(opts.outDir, `${name}.mp4`);
         const plan = opts.noAudio ? null : resolveAudioPlan(compileScene(ir));
@@ -1443,19 +2045,19 @@ __export(loadScene_exports, {
   loadScene: () => loadScene
 });
 import { build as build2 } from "esbuild";
-import { readFile as readFile4 } from "node:fs/promises";
+import { readFile as readFile5 } from "node:fs/promises";
 import { dirname as dirname6, resolve as resolve3 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-async function loadScene(path) {
-  if (path.endsWith(".json")) {
-    const ir = JSON.parse(await readFile4(path, "utf8"));
+async function loadScene(path2) {
+  if (path2.endsWith(".json")) {
+    const ir = JSON.parse(await readFile5(path2, "utf8"));
     validateScene(ir);
     return ir;
   }
   let code;
   try {
     const out = await build2({
-      entryPoints: [path],
+      entryPoints: [path2],
       bundle: true,
       format: "esm",
       platform: "neutral",
@@ -1469,12 +2071,12 @@ async function loadScene(path) {
     code = out.outputFiles[0].text;
   } catch (err) {
     throw new Error(
-      `failed to bundle ${path}:
+      `failed to bundle ${path2}:
 ${err instanceof Error ? err.message : String(err)}`
     );
   }
   const mod = await import(`data:text/javascript;base64,${Buffer.from(code).toString("base64")}`);
-  if (!mod.default) throw new Error(`${path} must default-export a scene`);
+  if (!mod.default) throw new Error(`${path2} must default-export a scene`);
   return mod.default;
 }
 var HERE, CORE_ENTRY;
@@ -1489,7 +2091,7 @@ var init_loadScene = __esm({
 
 // ../render-cli/src/reframe.ts
 import { spawn as spawn3, spawnSync } from "node:child_process";
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 import { mkdir as mkdir4, writeFile as writeFile5 } from "node:fs/promises";
 import { basename, isAbsolute as isAbsolute3, join as join6, resolve as resolve4 } from "node:path";
 import { dirname as dirname7 } from "node:path";
@@ -1500,15 +2102,20 @@ var ROOT2 = PACKAGED ? resolve4(HERE2, "..") : resolve4(HERE2, "..", "..", "..")
 var USER_CWD = process.env.INIT_CWD ?? process.cwd();
 var RENDER_CLI = PACKAGED ? join6(ROOT2, "dist", "cli.js") : join6(ROOT2, "packages", "render-cli", "src", "cli.ts");
 var ANALYZE = PACKAGED ? join6(ROOT2, "dist", "analyze.js") : join6(ROOT2, "benchmark", "harness", "motion", "analyze.ts");
+var TRACE = PACKAGED ? join6(ROOT2, "dist", "trace-cli.js") : join6(ROOT2, "benchmark", "harness", "motion", "trace-cli.ts");
 var CMD = PACKAGED ? "reframe" : "pnpm reframe";
 var USAGE = `reframe \u2014 declarative motion graphics
 
 usage:
   ${CMD} render <scene.ts|.json|.html> [--overlay edits.json]... [-o out.mp4] [--fps N] [--duration S] [--no-audio]
   ${CMD} batch <scene.ts> <data.json|csv> [-o outDir] [--overlay base.json]... [--concurrency N] [--fps N]
+  ${CMD} logo <logo.svg|brand-slug> ["Name"] [--motion <preset>] [--energy 0..1] [--seed N] [-o out.mp4]
+                                 animate a logo into a sting (presets: draw-bloom, punch-in,
+                                 rise-settle, slide-bank, reveal-orbit, spin-forge)
   ${CMD} preview                 open the scrub/edit UI (lists scenes in your directory)
   ${CMD} new <scene-name>        scaffold <scene-name>.ts in your directory
   ${CMD} motion <mp4|framesDir>  motion-profile a rendered clip
+  ${CMD} trace <ref.mp4> [--apply scene.ts]  extract a video's motion structure \u2192 MotionSketch / timeline
   ${CMD} guide [--regen]         print the scene-authoring guide (for you or your AI)
   ${CMD} demo                    run the edit-survival demo (3 mp4s into out/)
 `;
@@ -1531,9 +2138,9 @@ function run(cmd, args, opts = {}) {
     });
     let sawBrowserError = false;
     proc.stderr.on("data", (d) => {
-      const text = d.toString();
-      if (/Executable doesn't exist|browserType\.launch/.test(text)) sawBrowserError = true;
-      process.stderr.write(text);
+      const text2 = d.toString();
+      if (/Executable doesn't exist|browserType\.launch/.test(text2)) sawBrowserError = true;
+      process.stderr.write(text2);
     });
     proc.on("close", (code) => {
       if (code !== 0 && sawBrowserError) {
@@ -1614,7 +2221,7 @@ async function main() {
 
 ${USAGE}`);
       const inputPath = userPath(input);
-      if (!existsSync3(inputPath)) fail(`no such file: ${inputPath}`);
+      if (!existsSync4(inputPath)) fail(`no such file: ${inputPath}`);
       const mode = /\.(ts|json)$/.test(input) ? "ir" : /\.html$/.test(input) ? "html" : null;
       if (!mode) {
         fail(`cannot infer render mode from "${input}" \u2014 expected .ts/.json (reframe scene) or .html (GSAP page)`);
@@ -1637,12 +2244,49 @@ ${USAGE}`);
         await (PACKAGED ? run(process.execPath, [RENDER_CLI, mode, inputPath, ...outArgs]) : run("npx", ["tsx", RENDER_CLI, mode, inputPath, ...outArgs]))
       );
     }
+    case "logo": {
+      const positional = [];
+      const flags = {};
+      for (let i = 0; i < rest.length; i++) {
+        const a = rest[i];
+        if (a.startsWith("--")) flags[a.slice(2)] = rest[++i] ?? "";
+        else if (a === "-o") flags.o = rest[++i] ?? "";
+        else positional.push(a);
+      }
+      const arg = positional[0];
+      if (!arg) {
+        fail(`usage: ${CMD} logo <logo.svg | brand-slug> ["Display Name"] [--motion <preset>] [--energy 0..1] [--speed n] [--intensity 0..1] [--from left|right|top|bottom] [--seed n] [-o out.mp4]`);
+      }
+      preflightFfmpeg();
+      const { tmpdir: tmpdir4 } = await import("node:os");
+      const { resolveLogo: resolveLogo2, buildLogoSting: buildLogoSting2 } = await Promise.resolve().then(() => (init_logoSting(), logoSting_exports));
+      const num = (k) => flags[k] !== void 0 ? Number(flags[k]) : void 0;
+      console.log(`loading logo: ${arg} \u2026`);
+      const { data, slug } = await resolveLogo2(arg, positional[1], {
+        motion: flags.motion,
+        energy: num("energy"),
+        speed: num("speed"),
+        intensity: num("intensity"),
+        from: flags.from,
+        seed: num("seed")
+      });
+      const sceneIR = buildLogoSting2(data);
+      const tmp = join6(tmpdir4(), `reframe-logo-${slug}-${process.pid}.json`);
+      await writeFile5(tmp, JSON.stringify(sceneIR));
+      const outBase = PACKAGED ? join6(USER_CWD, "out") : join6(ROOT2, "out");
+      const out = flags.o ? userPath(flags.o) : join6(outBase, `logo-${slug}.mp4`);
+      await mkdir4(dirname7(out), { recursive: true });
+      console.log(`rendering ${data.name} (${data.paths.length} path${data.paths.length > 1 ? "s" : ""}, motion: ${data.motion ?? "reveal-orbit"}) \u2192 ${out}`);
+      process.exit(
+        await (PACKAGED ? run(process.execPath, [RENDER_CLI, "ir", tmp, "-o", out, "--no-audio"]) : run("npx", ["tsx", RENDER_CLI, "ir", tmp, "-o", out, "--no-audio"]))
+      );
+    }
     case "batch": {
       const [sceneArg, dataArg, ...flags] = rest;
       if (!sceneArg || !dataArg) fail(`usage: ${CMD} batch <scene.ts> <data.json|csv> [...]`);
       const scenePath = userPath(sceneArg);
       const dataPath = userPath(dataArg);
-      for (const p of [scenePath, dataPath]) if (!existsSync3(p)) fail(`no such file: ${p}`);
+      for (const p of [scenePath, dataPath]) if (!existsSync4(p)) fail(`no such file: ${p}`);
       preflightFfmpeg();
       let outDir = PACKAGED ? join6(USER_CWD, "out", "batch") : join6(ROOT2, "out", "batch");
       let concurrency = 3;
@@ -1657,15 +2301,15 @@ ${USAGE}`);
       }
       const { loadRows: loadRows2, runBatch: runBatch2 } = await Promise.resolve().then(() => (init_batch(), batch_exports));
       const { loadScene: loadScene2 } = await Promise.resolve().then(() => (init_loadScene(), loadScene_exports));
-      const { readFile: readFile5 } = await import("node:fs/promises");
-      const scene = await loadScene2(scenePath);
+      const { readFile: readFile6 } = await import("node:fs/promises");
+      const scene2 = await loadScene2(scenePath);
       const baseOverlays = await Promise.all(
-        baseOverlayPaths.map(async (p) => JSON.parse(await readFile5(p, "utf8")))
+        baseOverlayPaths.map(async (p) => JSON.parse(await readFile6(p, "utf8")))
       );
       const rows = await loadRows2(dataPath);
       if (rows.length === 0) fail(`${dataPath}: no data rows`);
       console.log(`batch: ${rows.length} rows \xD7 ${concurrency} workers \u2192 ${outDir}`);
-      const results = await runBatch2(scene, rows, {
+      const results = await runBatch2(scene2, rows, {
         outDir,
         baseOverlays,
         concurrency,
@@ -1714,7 +2358,7 @@ ${results.length - failed} rendered (${orphaned} with orphans), ${failed} failed
       const targetDir = inRepo ? join6(ROOT2, "examples", "scenes") : USER_CWD;
       const target = join6(targetDir, `${name}.ts`);
       const shown = inRepo ? `examples/scenes/${name}.ts` : `${name}.ts`;
-      if (existsSync3(target)) fail(`${shown} already exists`);
+      if (existsSync4(target)) fail(`${shown} already exists`);
       const id = name.split("-")[0] ?? name;
       await writeFile5(target, SCENE_TEMPLATE(name, id));
       console.log(`created ${shown}
@@ -1731,10 +2375,21 @@ ${results.length - failed} rendered (${orphaned} with orphans), ${failed} failed
         await (PACKAGED ? run(process.execPath, [ANALYZE, userPath(input), ...rest.slice(1)]) : run("npx", ["tsx", ANALYZE, userPath(input), ...rest.slice(1)]))
       );
     }
+    case "trace": {
+      const input = rest[0];
+      if (!input || input.startsWith("-")) fail(`usage: ${CMD} trace <ref.mp4> [--apply scene.ts] [-o out.json]`);
+      preflightFfmpeg();
+      const args = rest.slice(1).map(
+        (a, i) => rest.slice(1)[i - 1] === "--apply" || rest.slice(1)[i - 1] === "-o" ? userPath(a) : a
+      );
+      process.exit(
+        await (PACKAGED ? run(process.execPath, [TRACE, userPath(input), ...args]) : run("npx", ["tsx", TRACE, userPath(input), ...args]))
+      );
+    }
     case "guide": {
       const file = rest.includes("--regen") ? PACKAGED ? join6(ROOT2, "guides", "regen-contract.md") : join6(ROOT2, "docs", "regen-contract.md") : PACKAGED ? join6(ROOT2, "guides", "edsl-guide.md") : join6(ROOT2, "benchmark", "guides", "edsl-guide.md");
-      const { readFile: readFile5 } = await import("node:fs/promises");
-      process.stdout.write(await readFile5(file, "utf8"));
+      const { readFile: readFile6 } = await import("node:fs/promises");
+      process.stdout.write(await readFile6(file, "utf8"));
       return;
     }
     case "demo":