@pixerate/editor 0.69.0 → 0.70.0

package/dist/animation-editor/index.cjs

@@ -223,10 +223,11 @@ var SCENE_KEYS = ["version", "name", "description", "artwork", "shots", "clips",
 var SHOT_KEYS = ["id", "label", "camera", "at", "run", "hold", "speed"];
 var CAMERA_KEYS = ["x", "y", "width", "height", "frame", "padding", "ease", "ms", "geometric"];
 var BASE_KEYS = ["type", "targets", "duration", "delay", "stagger", "with", "ease", "note", "repeat", "repeatMode", "steps"];
+var DRAW_ORDER_KEYS = ["order", "pace", "align", "sortBy", "origin"];
 var COMMAND_KEYS = {
-  enter: [...BASE_KEYS, "style", "direction", "distance", "scale", "shape", "orientation"],
-  exit: [...BASE_KEYS, "style", "direction", "distance"],
-  draw: [...BASE_KEYS, "from", "to"],
+  enter: [...BASE_KEYS, ...DRAW_ORDER_KEYS, "style", "direction", "distance", "scale", "shape", "orientation"],
+  exit: [...BASE_KEYS, ...DRAW_ORDER_KEYS, "style", "direction", "distance"],
+  draw: [...BASE_KEYS, ...DRAW_ORDER_KEYS, "from", "to", "comet"],
   move: [...BASE_KEYS, "by", "to", "via", "pacing", "blend"],
   rotate: [...BASE_KEYS, "by", "to", "blend"],
   scale: [...BASE_KEYS, "to", "geometric", "blend"],
@@ -270,6 +271,14 @@ function commandShapeProblems(command2, where) {
     if (command2[key] !== void 0 && !isNum(command2[key])) p(`"${key}" must be a number.`);
   };
   if (command2.with !== void 0 && command2.with !== "after" && command2.with !== "previous") p(`"with" must be "after" or "previous".`);
+  if (DRAW_ORDER_KEYS.some((k) => command2[k] !== void 0)) {
+    if (type === "enter" && command2.style !== "draw" || type === "exit" && command2.style !== "undraw") p(`"order", "pace", "align", "sortBy" and "origin" go with drawing: style "${type === "enter" ? "draw" : "undraw"}".`);
+    if (command2.order !== void 0 && command2.order !== "together" && command2.order !== "sequence") p(`"order" must be "together" or "sequence" (one stroke after another).`);
+    if (command2.pace !== void 0 && command2.pace !== "time" && command2.pace !== "speed") p(`"pace" must be "time" (each stroke takes the whole time) or "speed" (all at one speed).`);
+    if (command2.align !== void 0 && command2.align !== "start" && command2.align !== "end") p(`"align" must be "start" or "end".`);
+    if (command2.sortBy !== void 0 && command2.sortBy !== "document" && command2.sortBy !== "distance") p(`"sortBy" must be "document" or "distance".`);
+    if (command2.origin !== void 0 && !isPoint(command2.origin)) p(`"origin" must be { "x": number, "y": number } (document units).`);
+  }
   if (command2.note !== void 0 && typeof command2.note !== "string") p(`"note" must be a string.`);
   if (type === "wait") {
     if (!isNum(command2.duration) || command2.duration < 0) p(`"duration" must be a number of milliseconds \u2265 0.`);
@@ -303,6 +312,8 @@ function commandShapeProblems(command2, where) {
     case "draw":
       fraction("from");
       fraction("to");
+      fraction("comet");
+      if (command2.comet !== void 0 && (command2.from !== void 0 || command2.to !== void 0)) p(`"comet" runs the whole path; leave out "from" and "to".`);
       break;
     case "move":
       if (command2.by === void 0 && command2.to === void 0) p(`give "by" (an offset) or "to" (a point).`);
@@ -1003,19 +1014,58 @@ function compileMotionScene(scene) {
       return typeof v === "number" ? v : 0;
     };
     const ease = command2.ease;
+    const drawWindows = (s, e, o) => {
+      const order2 = _nullishCoalesce(o.order, () => ( "together"));
+      const pace = _nullishCoalesce(o.pace, () => ( "time"));
+      if (order2 === "together" && pace === "time") return null;
+      const paths = entry.node.type === "path" ? [entry.node] : _chunkYJLCBA7Vcjs.collectPathNodes.call(void 0, entry.node);
+      let list = paths.map((p) => {
+        const at = nodes.get(p.id);
+        let first = { x: 0, y: 0 };
+        try {
+          const m = _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, p, _nullishCoalesce(_optionalChain([at, 'optionalAccess', _27 => _27.parentWorld]), () => ( _chunkYJLCBA7Vcjs.IDENTITY_MATRIX)), { effects: false })[0];
+          if (m && m.type === "M") first = { x: m.x, y: m.y };
+        } catch (e3) {
+        }
+        return { id: p.id, len: Math.max(1e-6, motionPathLength(p, _optionalChain([at, 'optionalAccess', _28 => _28.parentWorld]))), first };
+      });
+      if (!list.length) return null;
+      const span = Math.max(0, e - s);
+      if (order2 === "sequence") {
+        if (o.sortBy === "distance") {
+          const b = entry.bounds;
+          const origin = _nullishCoalesce(o.origin, () => ( (b ? { x: b.x + b.width / 2, y: b.y + b.height / 2 } : { x: 0, y: 0 })));
+          list = [...list].sort((a, c) => Math.hypot(a.first.x - origin.x, a.first.y - origin.y) - Math.hypot(c.first.x - origin.x, c.first.y - origin.y));
+        }
+        const total = list.reduce((sum, p) => sum + p.len, 0);
+        let at = s;
+        return list.map((p) => {
+          const w = { id: p.id, start: at, end: at + span * p.len / total };
+          at = w.end;
+          return w;
+        });
+      }
+      const longest = Math.max(...list.map((p) => p.len));
+      return list.map((p) => {
+        const d = span * p.len / longest;
+        return o.align === "end" ? { id: p.id, start: e - d, end: e } : { id: p.id, start: s, end: s + d };
+      });
+    };
     switch (command2.type) {
       case "enter": {
         const style = _nullishCoalesce(command2.style, () => ( "fade"));
         const opacity = rest("opacity");
         const reveal = style === "wipe" ? motionRevealClip(entry, { style, direction: command2.direction }) : style === "iris" ? motionRevealClip(entry, { style, shape: command2.shape }) : style === "split" ? motionRevealClip(entry, { style, orientation: command2.orientation }) : null;
-        for (const p of ["clipRect", "clipCircle"]) if (p !== _optionalChain([reveal, 'optionalAccess', _27 => _27.property]) && tracks.has(motionTrackKey(node, p))) seg(p, rest(p), "linear", start, start);
+        for (const p of ["clipRect", "clipCircle"]) if (p !== _optionalChain([reveal, 'optionalAccess', _29 => _29.property]) && tracks.has(motionTrackKey(node, p))) seg(p, rest(p), "linear", start, start);
         if (reveal) {
           seg("opacity", opacity, "linear", start, start);
           seg(reveal.property, reveal.to, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: reveal.from });
           break;
         }
         if (style === "draw") {
-          seg("drawEnd", 1, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, start + duration2 * 0.75, { from: 0 });
+          const windows = drawWindows(start, start + duration2 * 0.75, command2);
+          if (windows) for (const w of windows) push({ node: w.id, property: "drawEnd", start: w.start, end: w.end, from: 0, to: 1, ease: _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), ...where });
+          else seg("drawEnd", 1, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, start + duration2 * 0.75, { from: 0 });
           seg("fillOpacity", 1, MOTION_EASE_OUT, start + duration2 * 0.6, end, { from: 0 });
           break;
         }
@@ -1049,7 +1099,9 @@ function compileMotionScene(scene) {
         if (wipe) seg(wipe.property, wipe.to, _nullishCoalesce(ease, () => ( "ease-in")), start, end, { from: wipe.from });
         else if (style === "undraw") {
           seg("fillOpacity", 0, "ease-in", start, start + duration2 * 0.4);
-          seg("drawEnd", 0, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+          const windows = drawWindows(start, end, command2);
+          if (windows) for (const w of windows) push({ node: w.id, property: "drawEnd", start: w.start, end: w.end, from: valueAt(w.id, "drawEnd", w.start), to: 0, ease: _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), ...where });
+          else seg("drawEnd", 0, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
         } else if (style === "shrink") {
           seg("scaleX", 0, _nullishCoalesce(ease, () => ( "ease-in")));
           seg("scaleY", 0, _nullishCoalesce(ease, () => ( "ease-in")));
@@ -1064,21 +1116,31 @@ function compileMotionScene(scene) {
         break;
       }
       case "draw": {
-        const drawn = tracks.has(motionTrackKey(node, "drawEnd"));
-        seg("drawEnd", _nullishCoalesce(command2.to, () => ( 1)), _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, end, command2.from !== void 0 ? { from: command2.from } : drawn ? {} : { from: 0 });
+        const e = _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT));
+        const comet = command2.comet !== void 0 ? Math.min(1, Math.max(0, command2.comet)) : void 0;
+        const windows = _nullishCoalesce(drawWindows(start, end, command2), () => ( [{ id: node, start, end }]));
+        for (const w of windows) {
+          if (comet !== void 0) {
+            push({ node: w.id, property: "drawEnd", start: w.start, end: w.end, from: 0, to: 1 + comet, ease: e, ...where });
+            push({ node: w.id, property: "drawStart", start: w.start, end: w.end, from: -comet, to: 1, ease: e, ...where });
+            continue;
+          }
+          const drawn = tracks.has(motionTrackKey(w.id, "drawEnd"));
+          push({ node: w.id, property: "drawEnd", start: w.start, end: w.end, from: _nullishCoalesce(command2.from, () => ( (drawn ? valueAt(w.id, "drawEnd", w.start) : 0))), to: _nullishCoalesce(command2.to, () => ( 1)), ease: e, ...where });
+        }
         break;
       }
       case "move": {
         const e = _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT));
-        let dx = _nullishCoalesce(_optionalChain([command2, 'access', _28 => _28.by, 'optionalAccess', _29 => _29.x]), () => ( 0));
-        let dy = _nullishCoalesce(_optionalChain([command2, 'access', _30 => _30.by, 'optionalAccess', _31 => _31.y]), () => ( 0));
+        let dx = _nullishCoalesce(_optionalChain([command2, 'access', _30 => _30.by, 'optionalAccess', _31 => _31.x]), () => ( 0));
+        let dy = _nullishCoalesce(_optionalChain([command2, 'access', _32 => _32.by, 'optionalAccess', _33 => _33.y]), () => ( 0));
         if (command2.to) {
           const inv = _chunkYJLCBA7Vcjs.invertMatrix.call(void 0, entry.parentWorld);
           const target = _chunkYJLCBA7Vcjs.applyMatrix.call(void 0, inv, command2.to);
           dx = target.x - (entry.center.x + num("x"));
           dy = target.y - (entry.center.y + num("y"));
         }
-        if (_optionalChain([command2, 'access', _32 => _32.via, 'optionalAccess', _33 => _33.length])) {
+        if (_optionalChain([command2, 'access', _34 => _34.via, 'optionalAccess', _35 => _35.length])) {
           const inv = _chunkYJLCBA7Vcjs.invertMatrix.call(void 0, entry.parentWorld);
           const x0 = num("x");
           const y0 = num("y");
@@ -1189,7 +1251,7 @@ var MOTION_DRAW_EFFECT_ID = "~draw";
 var TRANSFORM_PROPS = ["x", "y", "rotation", "scaleX", "scaleY", "follow"];
 var tidy = (v) => Math.round(v * 1e6) / 1e6 || 0;
 function applyMotionControlValues(scene, values) {
-  if (!values || !_optionalChain([scene, 'access', _34 => _34.controls, 'optionalAccess', _35 => _35.length])) return scene;
+  if (!values || !_optionalChain([scene, 'access', _36 => _36.controls, 'optionalAccess', _37 => _37.length])) return scene;
   const map = /* @__PURE__ */ new Map();
   for (const control of scene.controls) {
     const value = values[control.name];
@@ -1235,7 +1297,7 @@ function shapeIn(entry, shape) {
 }
 function shapeAt(entry, timeline, nodes, time) {
   const track = timeline.tracks.get(motionTrackKey(entry.node.id, "shape"));
-  if (!_optionalChain([track, 'optionalAccess', _36 => _36.length])) return null;
+  if (!_optionalChain([track, 'optionalAccess', _38 => _38.length])) return null;
   const s = activeSegment(track, time);
   const fromId = String(s ? s.from : track[0].from);
   if (!s) return fromId === entry.node.id ? null : nodes.get(fromId) ? shapeIn(entry, nodes.get(fromId)) : null;
@@ -1252,14 +1314,14 @@ function motionFollowRoute(entry, path) {
   if (!path || path.node.type !== "path") return null;
   try {
     return _chunkO2UH7LZEcjs.transformBezierPath.call(void 0, _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, path.node, path.parentWorld, { effects: false }), _chunkYJLCBA7Vcjs.invertMatrix.call(void 0, entry.parentWorld));
-  } catch (e3) {
+  } catch (e4) {
     return null;
   }
 }
 function followAt(entry, timeline, nodes, time) {
   const track = timeline.tracks.get(motionTrackKey(entry.node.id, "follow"));
-  const s = _nullishCoalesce(activeSegment(track, time), () => ( _optionalChain([track, 'optionalAccess', _37 => _37[0]])));
-  if (!_optionalChain([s, 'optionalAccess', _38 => _38.path])) return null;
+  const s = _nullishCoalesce(activeSegment(track, time), () => ( _optionalChain([track, 'optionalAccess', _39 => _39[0]])));
+  if (!_optionalChain([s, 'optionalAccess', _40 => _40.path])) return null;
   const route = motionFollowRoute(entry, nodes.get(s.path));
   const progress = Number(trackValue(track, time));
   if (!route || !(progress >= 0)) return null;
@@ -1267,7 +1329,7 @@ function followAt(entry, timeline, nodes, time) {
     const at = _chunkO2UH7LZEcjs.bezierPathPointAtLength.call(void 0, route, Math.min(1, Math.max(0, progress)) * _chunkO2UH7LZEcjs.bezierPathLength.call(void 0, route));
     if (!at) return null;
     return { x: at.point[0], y: at.point[1], angle: s.rotate ? at.angle * 180 / Math.PI : 0 };
-  } catch (e4) {
+  } catch (e5) {
     return null;
   }
 }
@@ -1319,7 +1381,7 @@ function motionFrameAt(scene, time, options = {}) {
       if (out.visible === void 0) delete out.visible;
     }
     const effectTracks = [...timeline.tracks.keys()].filter((k) => k.startsWith(`${id}\0effect:`));
-    if (effectTracks.length && _optionalChain([out, 'access', _39 => _39.effects, 'optionalAccess', _40 => _40.length])) {
+    if (effectTracks.length && _optionalChain([out, 'access', _41 => _41.effects, 'optionalAccess', _42 => _42.length])) {
       out = {
         ...out,
         effects: out.effects.map((effect) => {
@@ -1432,7 +1494,7 @@ function motionPath(scene, id, options = {}) {
   const r = (n) => Math.round(n * 100) / 100;
   const centreAt = (t) => {
     const node = indexMotionNodes(motionFrameAtCache(scene, t)).get(id);
-    const b = _optionalChain([node, 'optionalAccess', _41 => _41.bounds]);
+    const b = _optionalChain([node, 'optionalAccess', _43 => _43.bounds]);
     return b ? { t: r(t), x: r(b.x + b.width / 2), y: r(b.y + b.height / 2) } : null;
   };
   const points = [];
@@ -1472,14 +1534,14 @@ function motionStageSvg(scene, time, options = {}) {
   const open = current.indexOf(">") + 1;
   const close = current.lastIndexOf("</svg>");
   const body = current.slice(open, close);
-  const bg = svgOptions.background !== false && scene.artwork.background ? _nullishCoalesce(_optionalChain([/^\s*<rect[^>]*\/>/, 'access', _42 => _42.exec, 'call', _43 => _43(body), 'optionalAccess', _44 => _44[0]]), () => ( "")) : "";
+  const bg = svgOptions.background !== false && scene.artwork.background ? _nullishCoalesce(_optionalChain([/^\s*<rect[^>]*\/>/, 'access', _44 => _44.exec, 'call', _45 => _45(body), 'optionalAccess', _46 => _46[0]]), () => ( "")) : "";
   return `${current.slice(0, open)}${bg}${ghosts.join("")}${body.slice(bg.length)}${paths}</svg>`;
 }
 
 // src/animation-editor/check.ts
 var MOTION_MIN_CHANGE_MS = 120;
 var NUMERIC_PARAMS = (node, effectId) => {
-  const effect = _optionalChain([node, 'access', _45 => _45.effects, 'optionalAccess', _46 => _46.find, 'call', _47 => _47((e) => e.id === effectId)]);
+  const effect = _optionalChain([node, 'access', _47 => _47.effects, 'optionalAccess', _48 => _48.find, 'call', _49 => _49((e) => e.id === effectId)]);
   if (!effect) return null;
   return Object.entries(effect.params).filter(([, v]) => typeof v === "number").map(([k]) => k);
 };
@@ -1510,7 +1572,11 @@ function visibleAt(timeline, id, time, node) {
   const circle = clip("clipCircle");
   if (Array.isArray(circle) && circle[2] <= 1e-4) return false;
   const hasFill = node.type === "path" ? !!node.fill && node.fill !== "none" : _chunkYJLCBA7Vcjs.collectPathNodes.call(void 0, node).some((p) => p.fill && p.fill !== "none");
-  return num("drawEnd", 1) > 0.01 || hasFill && num("fillOpacity", 1) > 0.01;
+  const drawn = num("drawEnd", 1) > 0.01 && (node.type === "path" || _chunkYJLCBA7Vcjs.collectPathNodes.call(void 0, node).length === 0 || _chunkYJLCBA7Vcjs.collectPathNodes.call(void 0, node).some((p) => {
+    const v = trackValue(timeline.tracks.get(motionTrackKey(p.id, "drawEnd")), time);
+    return typeof v !== "number" || v > 0.01;
+  }));
+  return drawn || hasFill && num("fillOpacity", 1) > 0.01;
 }
 function checkMotionScene(scene) {
   const issues = [];
@@ -1556,7 +1622,7 @@ function checkMotionScene(scene) {
       if (command2.type === "follow" && known(command2.path, "unknown-path", "path", where) && nodes.get(command2.path).node.type !== "path")
         issues.push(motionIssue("not-a-path", `"${command2.path}" is a group; follow a single path node.`, { ...where, ids: [command2.path] }));
       if (command2.type === "morph") known(command2.into, "unknown-shape", "shape", where);
-      if (command2.type === "play" && !_optionalChain([scene, 'access', _48 => _48.clips, 'optionalAccess', _49 => _49[command2.clip]]))
+      if (command2.type === "play" && !_optionalChain([scene, 'access', _50 => _50.clips, 'optionalAccess', _51 => _51[command2.clip]]))
         issues.push(motionIssue("unknown-clip", `There is no clip ${namedWithSuggestion(command2.clip, Object.keys(_nullishCoalesce(scene.clips, () => ( {}))))}; define it with set_animation_clip.`, where));
       if (command2.type === "match" && known(command2.into, "unknown-shape", "group", where)) {
         const into = nodes.get(command2.into);
@@ -1649,7 +1715,7 @@ function checkMotionScene(scene) {
     if (!shot.at) return;
     const timing = timeline.shots[i];
     if (timing.cue === void 0) {
-      const what = shot.at.beat !== void 0 ? `beat ${shot.at.beat}, but the scene has no beat grid; set one with set_animation_settings ({ "beat": { "bpm": \u2026 } })` : `word ${shot.at.word}, but the narration has ${_nullishCoalesce(_optionalChain([scene, 'access', _50 => _50.narration, 'optionalAccess', _51 => _51.words, 'access', _52 => _52.length]), () => ( 0))} words (indexes from 0)`;
+      const what = shot.at.beat !== void 0 ? `beat ${shot.at.beat}, but the scene has no beat grid; set one with set_animation_settings ({ "beat": { "bpm": \u2026 } })` : `word ${shot.at.word}, but the narration has ${_nullishCoalesce(_optionalChain([scene, 'access', _52 => _52.narration, 'optionalAccess', _53 => _53.words, 'access', _54 => _54.length]), () => ( 0))} words (indexes from 0)`;
       issues.push(motionIssue("unknown-cue", `Shot "${shot.id}" is cued to ${what}.`, { shot: shot.id }));
     } else if (timing.missedBy !== void 0) {
       const late = Math.round(timing.missedBy);
@@ -1682,7 +1748,7 @@ function checkMotionScene(scene) {
     const cam = frame.camera;
     const docIndex = indexMotionNodes(frame.document.nodes);
     for (const id of command2.targets) {
-      const b = _optionalChain([docIndex, 'access', _53 => _53.get, 'call', _54 => _54(id), 'optionalAccess', _55 => _55.bounds]);
+      const b = _optionalChain([docIndex, 'access', _55 => _55.get, 'call', _56 => _56(id), 'optionalAccess', _57 => _57.bounds]);
       if (!b || reported.has(id) || !visibleAt(timeline, id, timing.end, nodes.get(id).node)) continue;
       const outside = b.x + b.width < cam.x || b.y + b.height < cam.y || b.x > cam.x + cam.width || b.y > cam.y + cam.height;
       if (outside) {
@@ -1906,9 +1972,9 @@ function applyMotionEdits(scene, edits) {
   let next = scene;
   for (let i = 0; i < list.length; i++) {
     const edit = list[i];
-    const prefix = list.length > 1 ? `op ${i + 1} (${_optionalChain([edit, 'optionalAccess', _56 => _56.op])}): ` : "";
+    const prefix = list.length > 1 ? `op ${i + 1} (${_optionalChain([edit, 'optionalAccess', _58 => _58.op])}): ` : "";
     if (!edit || !MOTION_EDIT_OPS.includes(edit.op))
-      return { ok: false, error: `${prefix}Unknown op ${namedWithSuggestion(String(_optionalChain([edit, 'optionalAccess', _57 => _57.op])), MOTION_EDIT_OPS)}. Nothing was changed.` };
+      return { ok: false, error: `${prefix}Unknown op ${namedWithSuggestion(String(_optionalChain([edit, 'optionalAccess', _59 => _59.op])), MOTION_EDIT_OPS)}. Nothing was changed.` };
     try {
       next = applyOne(next, edit);
     } catch (error) {
@@ -2068,7 +2134,7 @@ function toFlairSvgMotion(scene, options = {}) {
         const wrapper = freshId(`${id}--follow`);
         const centre = freshId(`${id}--follow-centre`);
         const c = entry.center;
-        const at = _optionalChain([motionNodeOffset, 'call', _58 => _58(entry, timeline, 0, nodes), 'optionalAccess', _59 => _59.follow]);
+        const at = _optionalChain([motionNodeOffset, 'call', _60 => _60(entry, timeline, 0, nodes), 'optionalAccess', _61 => _61.follow]);
         const placed = at ? `translate(${f(at.x)} ${f(at.y)})${at.angle ? ` rotate(${f(at.angle)})` : ""}` : void 0;
         (wrap[id] ??= []).push({ id: wrapper, ...placed ? { transform: placed } : {} }, { id: centre, transform: `translate(${f(-c.x)} ${f(-c.y)})` });
         follows.push({ id, wrapper, routes: ids, segments: followSegments.filter((seg) => seg.path && ids.has(seg.path)) });
@@ -2128,7 +2194,7 @@ function toFlairSvgMotion(scene, options = {}) {
           exact: () => false,
           value: (t) => {
             const frame = motionFrameAt(scene, t, { draw: false, offsets: false });
-            const now = _chunkYJLCBA7Vcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _60 => _60(frame.document.nodes), 'access', _61 => _61.get, 'call', _62 => _62(id), 'optionalAccess', _63 => _63.node]));
+            const now = _chunkYJLCBA7Vcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _62 => _62(frame.document.nodes), 'access', _63 => _63.get, 'call', _64 => _64(id), 'optionalAccess', _65 => _65.node]));
             if (!now || now.type !== "path") return "";
             const bezier = _chunkO2UH7LZEcjs.transformBezierPath.call(void 0, _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, now, _chunkYJLCBA7Vcjs.IDENTITY_MATRIX, { effects: false }), inverse);
             return _chunkO2UH7LZEcjs.bezierPathToSvg.call(void 0, bezier, { precision: Math.min(precision, 2) });
@@ -2149,8 +2215,8 @@ function toFlairSvgMotion(scene, options = {}) {
       ...delay > 0 ? { delay: round2(delay) } : {},
       ms: round2(ms),
       ease: written,
-      ..._optionalChain([segment, 'optionalAccess', _64 => _64.behavior]) ? { behavior: segment.behavior } : {},
-      ..._optionalChain([segment, 'optionalAccess', _65 => _65.steps]) ? { strobe: segment.steps } : {}
+      ..._optionalChain([segment, 'optionalAccess', _66 => _66.behavior]) ? { behavior: segment.behavior } : {},
+      ..._optionalChain([segment, 'optionalAccess', _67 => _67.steps]) ? { strobe: segment.steps } : {}
     };
     if (channel.kind === "view") animate.push({ ...base, view: to });
     else if (channel.kind === "draw") animate.push({ ...base, draw: [from, to] });
@@ -2239,7 +2305,7 @@ function toFlairSvgMotion(scene, options = {}) {
   let svg = _chunkYJLCBA7Vcjs.vectorDocumentToSvg.call(void 0, { ...scene.artwork, nodes: _chunkYJLCBA7Vcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) }, { pretty: false, precision, wrap });
   if (routes.length) svg = svg.replace(/^(<svg[^>]*>)/, `$1<defs>${routes.join("")}</defs>`);
   let motion = { svg, animate };
-  if (_optionalChain([scene, 'access', _66 => _66.controls, 'optionalAccess', _67 => _67.length])) {
+  if (_optionalChain([scene, 'access', _68 => _68.controls, 'optionalAccess', _69 => _69.length])) {
     const declarations = scene.controls.map((c) => `{{${c.name}: color default=${c.default.toUpperCase()}${c.label ? ` label='${c.label.replace(/'/g, "\u2019")}'` : ""}}}`).join(" ");
     const swap = (text) => scene.controls.reduce((s, c) => s.replace(new RegExp(`${c.default}(?![0-9a-fA-F])`, "gi"), `{{${c.name}}}`), text);
     svg = svg.replace(/^(<svg[^>]*>)/, `$1<!-- ${declarations} -->`);
@@ -2261,7 +2327,7 @@ function toFlairVectorEffect(scene, options = {}) {
     tags: _nullishCoalesce(options.tags, () => ( [])),
     motion: out.motion,
     hold: out.hold,
-    ..._optionalChain([scene, 'access', _68 => _68.presets, 'optionalAccess', _69 => _69.length]) ? { presets: scene.presets } : {},
+    ..._optionalChain([scene, 'access', _70 => _70.presets, 'optionalAccess', _71 => _71.length]) ? { presets: scene.presets } : {},
     ...out.trigger ? { trigger: out.trigger } : {}
   };
 }
@@ -2305,7 +2371,7 @@ function resolvePlaceholders(motion, notes) {
   const filled = text.replace(PLACEHOLDER, (_, name) => {
     const d = declared.get(name);
     if (!d) unknown.add(name);
-    return (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _70 => _70.value]), () => ( ""))).replace(/"/g, '\\"');
+    return (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _72 => _72.value]), () => ( ""))).replace(/"/g, '\\"');
   });
   for (const name of unknown) notes.push(`Placeholder "{{${name}}}" has no declaration, so it was left empty.`);
   return { motion: JSON.parse(filled), controls };
@@ -2359,7 +2425,7 @@ function commandsFor(anim, nodes, entered, notes) {
   if (anim.along) {
     const path = nodes.get(anim.along);
     if (!path || path.node.type !== "path") notes.push(`${where} follows "${anim.along}", which is not a path in the artwork; the follow was skipped.`);
-    else out.push({ type: "follow", targets, path: anim.along, from: _nullishCoalesce(_optionalChain([anim, 'access', _71 => _71.at, 'optionalAccess', _72 => _72[0]]), () => ( 0)), to: _nullishCoalesce(_optionalChain([anim, 'access', _73 => _73.at, 'optionalAccess', _74 => _74[1]]), () => ( 1)), ...anim.orient ? { rotate: true } : {}, ...timing, ...ease(MOTION_EASE_IN_OUT) });
+    else out.push({ type: "follow", targets, path: anim.along, from: _nullishCoalesce(_optionalChain([anim, 'access', _73 => _73.at, 'optionalAccess', _74 => _74[0]]), () => ( 0)), to: _nullishCoalesce(_optionalChain([anim, 'access', _75 => _75.at, 'optionalAccess', _76 => _76[1]]), () => ( 1)), ...anim.orient ? { rotate: true } : {}, ...timing, ...ease(MOTION_EASE_IN_OUT) });
   }
   for (const [attr, [a, b]] of Object.entries(_nullishCoalesce(anim.attrs, () => ( {})))) {
     if (attr === "opacity") {
@@ -2370,7 +2436,7 @@ function commandsFor(anim, nodes, entered, notes) {
         out.push({ type: "enter", targets, style: "fade", ...timing, ...ease(MOTION_EASE_OUT) });
       } else out.push({ type: "fade", targets, to: Math.min(1, Math.max(0, to)), ...timing, ...ease(MOTION_EASE_IN_OUT) });
     } else if (attr === "fill" || attr === "stroke") {
-      if (_optionalChain([behavior, 'optionalAccess', _75 => _75.type]) === "pulse") out.push({ type: "color-pulse", targets, color: String(b), paint: attr, count: _nullishCoalesce(behavior.count, () => ( 1)), ...timing, ...ease("linear") });
+      if (_optionalChain([behavior, 'optionalAccess', _77 => _77.type]) === "pulse") out.push({ type: "color-pulse", targets, color: String(b), paint: attr, count: _nullishCoalesce(behavior.count, () => ( 1)), ...timing, ...ease("linear") });
       else {
         if (behavior) notes.push(`${where}: a ${attr} ${behavior.type} became a plain colour change.`);
         out.push({ type: "style", targets, [attr]: String(b), ...timing, ...ease(MOTION_EASE_IN_OUT) });
@@ -2653,7 +2719,7 @@ function toLottie(scene, options = {}) {
     const shapeSegments = [...timeline.tracks.entries()].filter(([k]) => k.startsWith(`${path.id}\0`) && (k.endsWith("\0shape") || k.includes("\0effect:"))).flatMap(([, v]) => v);
     const geometryAt = (t) => {
       if (!shapeSegments.length) return _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, path);
-      const now = _optionalChain([indexMotionNodes, 'call', _76 => _76(motionFrameAt(scene, t, { draw: false, offsets: false }).document.nodes), 'access', _77 => _77.get, 'call', _78 => _78(path.id), 'optionalAccess', _79 => _79.node]);
+      const now = _optionalChain([indexMotionNodes, 'call', _78 => _78(motionFrameAt(scene, t, { draw: false, offsets: false }).document.nodes), 'access', _79 => _79.get, 'call', _80 => _80(path.id), 'optionalAccess', _81 => _81.node]);
       return now && now.type === "path" ? _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, _chunkYJLCBA7Vcjs.expandVectorAppearances.call(void 0, [now])[0]) : _chunkYJLCBA7Vcjs.vectorPathWorldBezier.call(void 0, path);
     };
     const rest = lottieContours(_chunkO2UH7LZEcjs.toBezierPath.call(void 0, geometryAt(0)), round2);
@@ -2681,11 +2747,13 @@ function toLottie(scene, options = {}) {
     const widthFrom = owner(path, "strokeWidth");
     const fadeFrom = owner(path, "fillOpacity");
     const drawFrom = owner(path, "drawEnd");
-    if (drawFrom) {
-      const draw = track(drawFrom, "drawEnd");
-      items.push({ ty: "tm", nm: "Draw on", s: { a: 0, k: 0 }, e: animate(draw, (t) => [Math.min(1, Math.max(0, Number(_nullishCoalesce(trackValue(draw, t), () => ( 1))))) * 100]), o: { a: 0, k: 0 }, m: 1 });
+    const tailFrom = owner(path, "drawStart");
+    if (drawFrom || tailFrom) {
+      const pct = (track2, fallback) => (t) => [Math.min(1, Math.max(0, Number(_nullishCoalesce(trackValue(track2, t), () => ( fallback))))) * 100];
+      const head = drawFrom ? track(drawFrom, "drawEnd") : [];
+      const tail = tailFrom ? track(tailFrom, "drawStart") : [];
+      items.push({ ty: "tm", nm: "Draw on", s: tail.length ? animate(tail, pct(tail, 0)) : { a: 0, k: 0 }, e: head.length ? animate(head, pct(head, 1)) : { a: 0, k: 100 }, o: { a: 0, k: 0 }, m: 1 });
     }
-    if (owner(path, "drawStart")) notes.push(`"${path.id}": drawing from a start other than 0 is not exported.`);
     const stroke = paintOf(path.stroke, "stroke", path.id);
     if (stroke || strokeFrom) {
       const colour = strokeFrom ? track(strokeFrom, "stroke") : [];
@@ -2699,7 +2767,7 @@ function toLottie(scene, options = {}) {
         lj: path.strokeLinejoin === "round" ? 2 : path.strokeLinejoin === "bevel" ? 3 : 1,
         ml: 4
       });
-      if (_optionalChain([path, 'access', _80 => _80.strokeDasharray, 'optionalAccess', _81 => _81.length])) notes.push(`"${path.id}": its dashes are not exported; the stroke is solid.`);
+      if (_optionalChain([path, 'access', _82 => _82.strokeDasharray, 'optionalAccess', _83 => _83.length])) notes.push(`"${path.id}": its dashes are not exported; the stroke is solid.`);
       if (path.strokeAlign && path.strokeAlign !== "center") notes.push(`"${path.id}": its stroke is drawn centred (Lottie has no inside or outside strokes).`);
     }
     const fill = paintOf(path.fill, "fill", path.id);
@@ -2850,7 +2918,7 @@ var AnimationEditorController = (_class = class {
       time: p.time,
       playing: p.playing,
       loop: p.loop,
-      currentShot: _nullishCoalesce(_optionalChain([motionShotAt, 'call', _82 => _82(timeline, p.time), 'optionalAccess', _83 => _83.id]), () => ( null)),
+      currentShot: _nullishCoalesce(_optionalChain([motionShotAt, 'call', _84 => _84(timeline, p.time), 'optionalAccess', _85 => _85.id]), () => ( null)),
       selection: this.selection,
       readOnly: this.readOnly,
       error: this.error,
@@ -2889,7 +2957,7 @@ var AnimationEditorController = (_class = class {
       this.applying = false;
     }
     this.notify();
-    _optionalChain([this, 'access', _84 => _84.onChange, 'optionalCall', _85 => _85(scene)]);
+    _optionalChain([this, 'access', _86 => _86.onChange, 'optionalCall', _87 => _87(scene)]);
   }
   commit(label, next) {
     const before = this.scene;
@@ -3071,11 +3139,19 @@ var BLEND = (fallback) => ({
   enum: [...MOTION_BLENDS],
   description: `"add" makes it a layer over the pose that stacks with other changes (a shake on a slide); "replace" makes it a change the next one takes over from (default ${fallback}).`
 });
+var DRAW_ORDER = {
+  order: { type: "string", enum: ["together", "sequence"], description: "For drawing a group or several paths: together (default) or sequence (one stroke after another, each for a time in proportion to its length)." },
+  pace: { type: "string", enum: ["time", "speed"], description: "With together: time (default, every stroke takes the whole time) or speed (all at one speed, so short strokes take less)." },
+  align: { type: "string", enum: ["start", "end"], description: "With pace speed: start them together (default) or finish them together." },
+  sortBy: { type: "string", enum: ["document", "distance"], description: "With sequence: stacking order (default) or distance from origin (a radial reveal)." },
+  origin: object({ x: { type: "number", description: "Document units." }, y: { type: "number", description: "Document units." } }, ["x", "y"], "With sortBy distance: where strokes are drawn out from (default the target's centre).")
+};
 var command = (type, description, extra = {}, required = []) => object({ type: { const: type, description }, ...BASE, ...extra }, ["type", "targets", ...required], description);
 var MOTION_COMMAND_SCHEMA = {
   description: `A command (one of ${MOTION_COMMAND_TYPES.join(", ")}). Commands in a shot play one after another unless "with": "previous".`,
   oneOf: [
     command("enter", "Brings hidden targets in; they are hidden before this shot.", {
+      ...DRAW_ORDER,
       style: {
         type: "string",
         enum: [...MOTION_ENTER_STYLES],
@@ -3088,11 +3164,12 @@ var MOTION_COMMAND_SCHEMA = {
       orientation: { type: "string", enum: [...MOTION_SPLIT_ORIENTATIONS], description: "For split: horizontal (default) opens up and down from a horizontal line through the middle; vertical opens left and right." }
     }),
     command("exit", "Takes targets out.", {
+      ...DRAW_ORDER,
       style: { type: "string", enum: [...MOTION_EXIT_STYLES], description: "fade (default), shrink, slide, undraw, or wipe (hides behind a travelling edge through a clip over the target's box: a wipe in, reversed)." },
       direction: { type: "string", enum: [...MOTION_DIRECTIONS], description: "For slide: direction of travel (default down). For wipe: the way the edge travels (default right, hiding from the left)." },
       distance: { type: "number", description: "For slide: document units (default 40)." }
     }),
-    command("draw", "Draws strokes on (or off) to a fraction of their length.", { to: FRACTION("Fraction drawn at the end (default 1)."), from: FRACTION("Fraction drawn at the start (default: what is drawn now).") }),
+    command("draw", "Draws strokes on (or off) to a fraction of their length.", { ...DRAW_ORDER, comet: FRACTION("A travelling stroke this fraction of the length long: it runs along the path and off the end (leave out from and to)."), to: FRACTION("Fraction drawn at the end (default 1)."), from: FRACTION("Fraction drawn at the start (default: what is drawn now).") }),
     command("move", "Moves targets by an offset or so their centre lands on a point.", { via: { type: "array", items: POINT("A point the centre passes through."), minItems: 1, maxItems: 64, description: 'Waypoints (document units) the centre passes through on the way to "to" or "by", smoothly (velocity carries through each) and without overshooting any. Default length 700 ms + 400 per waypoint.' }, pacing: { type: "string", enum: ["even", "equal"], description: "With via: even (default) keeps the speed steady along the path; equal gives each stretch the same time." }, blend: BLEND("replace"), by: POINT("Offset in document units."), to: POINT("Point (document coordinates) for the centre.") }),
     command("rotate", "Turns targets about their centre (degrees, clockwise).", { blend: BLEND("replace"), by: { type: "number", description: "Degrees to turn by." }, to: { type: "number", description: "Angle to turn to, in degrees from rest." } }),
     command("scale", "Scales targets about their centre (1 = rest size).", { blend: BLEND("replace"), to: { description: "A factor, or { x, y } factors.", anyOf: [{ type: "number" }, POINT("Factors per axis.")] }, geometric: { type: "boolean", description: "Grow by a steady factor, which reads as an even zoom (default false)." } }, ["to"]),
@@ -3426,9 +3503,9 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ from = 0, to, limit = 200 }) => {
       const s = scene();
       const timeline = compileMotionScene(s);
-      const words = _nullishCoalesce(_optionalChain([s, 'access', _86 => _86.narration, 'optionalAccess', _87 => _87.words]), () => ( []));
+      const words = _nullishCoalesce(_optionalChain([s, 'access', _88 => _88.narration, 'optionalAccess', _89 => _89.words]), () => ( []));
       const end = _nullishCoalesce(to, () => ( Math.max(timeline.duration, words.length ? _nullishCoalesce(words[words.length - 1].end, () => ( words[words.length - 1].start)) : 0)));
-      const shotAt = (ms) => _optionalChain([timeline, 'access', _88 => _88.shots, 'access', _89 => _89.find, 'call', _90 => _90((x) => ms >= x.start && ms < x.end), 'optionalAccess', _91 => _91.id]);
+      const shotAt = (ms) => _optionalChain([timeline, 'access', _90 => _90.shots, 'access', _91 => _91.find, 'call', _92 => _92((x) => ms >= x.start && ms < x.end), 'optionalAccess', _93 => _93.id]);
       const beats = [];
       if (s.beat && s.beat.bpm > 0) {
         const first = Math.max(0, Math.ceil(motionBeatAt(s.beat, from).beat - 1e-9));
@@ -3678,7 +3755,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     inputSchema: object({ shot: SHOT_ID, commands: { type: "array", items: MOTION_COMMAND_SCHEMA, minItems: 1, description: "Commands to add." }, at: { type: "integer", minimum: 0, description: "Index in the run (default: the end)." } }, ["shot", "commands"]),
     annotations: { title: "Add commands to a shot", ...WRITE },
     handler: ({ shot, commands, at }) => {
-      const before = _nullishCoalesce(_optionalChain([scene, 'call', _92 => _92(), 'access', _93 => _93.shots, 'access', _94 => _94.find, 'call', _95 => _95((s) => s.id === shot), 'optionalAccess', _96 => _96.run, 'access', _97 => _97.length]), () => ( 0));
+      const before = _nullishCoalesce(_optionalChain([scene, 'call', _94 => _94(), 'access', _95 => _95.shots, 'access', _96 => _96.find, 'call', _97 => _97((s) => s.id === shot), 'optionalAccess', _98 => _98.run, 'access', _99 => _99.length]), () => ( 0));
       const first = _nullishCoalesce(at, () => ( before));
       return apply({ op: "add_commands", shot, commands, at }, "Add commands", (s) => {
         const shots = describeMotionShots(s);
@@ -3840,6 +3917,7 @@ Commands
 - enter (fade, pop, grow, slide, draw) and exit (fade, shrink, slide, undraw) bring things in and out.
 - enter also reveals through a clip over the target's box: wipe (behind an edge travelling "direction", default right), iris (from the centre; "shape": circle or box) and split (from a line through the middle; "orientation": horizontal or vertical). exit wipe hides the same way. Reveals need a width and a height: use draw / undraw for a straight line.
 - draw draws strokes on to a fraction; move, rotate, scale and fade change the pose (about the centre); style blends solid colours and stroke width.
+- Drawing a group of strokes: "order": "sequence" draws them one after another (a signature, a diagram), "sortBy": "distance" from "origin" reveals outward, "pace": "speed" keeps one speed; draw with "comet": 0.2 sends a short stroke along a path and off the end.
 - Reuse motion: set_animation_clip defines a clip (commands targeting "$"), and { "type": "play", "clip": name, "targets": [...] } plays it on any nodes (with stagger and speed). copy_animation gives other nodes one node's motion.
 - move takes "via" waypoints for a curved, smooth path that passes exactly through each point (steady speed by default); use it instead of chaining moves, which stop at each point.
 - enter also has zoom (settles from larger) and rise (rises a short way, overshooting a touch); pop and zoom take a starting "scale".
@@ -3867,7 +3945,7 @@ var TIMING = /* @__PURE__ */ new Set(["duration", "delay", "stagger", "with", "e
 var COLORS = /* @__PURE__ */ new Set(["fill", "stroke", "color"]);
 var NODES = /* @__PURE__ */ new Set(["into", "path"]);
 function branch(type) {
-  return (_nullishCoalesce(MOTION_COMMAND_SCHEMA.oneOf, () => ( []))).find((b) => _optionalChain([b, 'access', _98 => _98.properties, 'optionalAccess', _99 => _99.type, 'optionalAccess', _100 => _100.const]) === type);
+  return (_nullishCoalesce(MOTION_COMMAND_SCHEMA.oneOf, () => ( []))).find((b) => _optionalChain([b, 'access', _100 => _100.properties, 'optionalAccess', _101 => _101.type, 'optionalAccess', _102 => _102.const]) === type);
 }
 function unitOf(type, name) {
   if (name === "duration" || name === "delay" || name === "stagger") return "ms";
@@ -3902,7 +3980,7 @@ function kindOf(name, schema) {
 }
 function motionCommandFields(type) {
   const schema = branch(type);
-  if (!_optionalChain([schema, 'optionalAccess', _101 => _101.properties])) return [];
+  if (!_optionalChain([schema, 'optionalAccess', _103 => _103.properties])) return [];
   const required = new Set(_nullishCoalesce(schema.required, () => ( [])));
   const fields = Object.entries(schema.properties).filter(([name]) => name !== "type").map(([name, s]) => {
     const kind = kindOf(name, s);
@@ -3959,7 +4037,7 @@ function defaultMotionCommand(type, targets, scene) {
   if (type === "wait") return { type: "wait", duration: 500 };
   if (!targets.length) return { error: "Pick a target first: click an element on the stage." };
   const nodes = [...indexMotionNodes(scene.artwork.nodes).values()];
-  const other = (pred) => _optionalChain([nodes, 'access', _102 => _102.find, 'call', _103 => _103((e) => !targets.includes(e.node.id) && pred(e)), 'optionalAccess', _104 => _104.node, 'access', _105 => _105.id]);
+  const other = (pred) => _optionalChain([nodes, 'access', _104 => _104.find, 'call', _105 => _105((e) => !targets.includes(e.node.id) && pred(e)), 'optionalAccess', _106 => _106.node, 'access', _107 => _107.id]);
   const base = { targets: [...targets] };
   switch (type) {
     case "scale":
@@ -3990,8 +4068,8 @@ function defaultMotionCommand(type, targets, scene) {
     }
     case "effect": {
       for (const id of targets) {
-        const node = _optionalChain([nodes, 'access', _106 => _106.find, 'call', _107 => _107((e) => e.node.id === id), 'optionalAccess', _108 => _108.node]);
-        for (const effect of _nullishCoalesce(_optionalChain([node, 'optionalAccess', _109 => _109.effects]), () => ( []))) {
+        const node = _optionalChain([nodes, 'access', _108 => _108.find, 'call', _109 => _109((e) => e.node.id === id), 'optionalAccess', _110 => _110.node]);
+        for (const effect of _nullishCoalesce(_optionalChain([node, 'optionalAccess', _111 => _111.effects]), () => ( []))) {
           const param = Object.entries(effect.params).find(([, v]) => typeof v === "number");
           if (param) return { type, ...base, effect: effect.id, param: param[0], to: param[1] + 1 };
         }
@@ -4016,11 +4094,11 @@ function motionCommandRows(scene, shotId) {
   return scene.shots[index].run.map((command2, i) => {
     const t = timeline.commands.find((c) => c.shotIndex === index && c.command === i);
     const primitive = motionFlairPrimitive(command2);
-    return { index: i, command: command2, summary: motionCommandSummary(command2), start: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _110 => _110.start]), () => ( 0)), end: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _111 => _111.end]), () => ( 0)), ...primitive ? { flairPrimitive: primitive } : {} };
+    return { index: i, command: command2, summary: motionCommandSummary(command2), start: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _112 => _112.start]), () => ( 0)), end: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _113 => _113.end]), () => ( 0)), ...primitive ? { flairPrimitive: primitive } : {} };
   });
 }
 function duplicateMotionCommandEdit(scene, shot, command2) {
-  const run = _nullishCoalesce(_optionalChain([scene, 'access', _112 => _112.shots, 'access', _113 => _113.find, 'call', _114 => _114((s) => s.id === shot), 'optionalAccess', _115 => _115.run]), () => ( []));
+  const run = _nullishCoalesce(_optionalChain([scene, 'access', _114 => _114.shots, 'access', _115 => _115.find, 'call', _116 => _116((s) => s.id === shot), 'optionalAccess', _117 => _117.run]), () => ( []));
   return { op: "add_commands", shot, commands: run[command2] ? [structuredClone(run[command2])] : [], at: command2 + 1 };
 }
 var MOTION_EASE_CHOICES = [
@@ -4105,7 +4183,7 @@ function motionCueFromKey(key) {
 function motionCueChoices(scene, limit = 256) {
   const choices = [];
   const s = (ms) => `${(ms / 1e3).toFixed(2)} s`;
-  const end = Math.max(compileMotionScene(scene).duration, ..._nullishCoalesce(_optionalChain([scene, 'access', _116 => _116.narration, 'optionalAccess', _117 => _117.words, 'access', _118 => _118.map, 'call', _119 => _119((w) => _nullishCoalesce(w.end, () => ( w.start)))]), () => ( [0]))) + 2e3;
+  const end = Math.max(compileMotionScene(scene).duration, ..._nullishCoalesce(_optionalChain([scene, 'access', _118 => _118.narration, 'optionalAccess', _119 => _119.words, 'access', _120 => _120.map, 'call', _121 => _121((w) => _nullishCoalesce(w.end, () => ( w.start)))]), () => ( [0]))) + 2e3;
   if (scene.beat && scene.beat.bpm > 0) {
     for (let beat = 0; choices.length < limit; beat++) {
       const time = motionBeatTime(scene.beat, beat);
@@ -4115,7 +4193,7 @@ function motionCueChoices(scene, limit = 256) {
       choices.push({ value: `beat:${beat}`, label: `Beat ${beat} (bar ${at.bar}.${at.beatInBar}) \xB7 ${s(time)}`, time });
     }
   }
-  _optionalChain([scene, 'access', _120 => _120.narration, 'optionalAccess', _121 => _121.words, 'access', _122 => _122.forEach, 'call', _123 => _123((w, i) => {
+  _optionalChain([scene, 'access', _122 => _122.narration, 'optionalAccess', _123 => _123.words, 'access', _124 => _124.forEach, 'call', _125 => _125((w, i) => {
     if (choices.length < limit * 2) choices.push({ value: `word:${i}`, label: `Word ${i} \u201C${w.text}\u201D \xB7 ${s(w.start)}`, time: w.start });
   })]);
   return choices;
@@ -4124,7 +4202,7 @@ function motionShotCueTime(scene, cue) {
   return cue ? motionCueTime(scene, cue) : void 0;
 }
 function formatMotionNarration(narration) {
-  return (_nullishCoalesce(_optionalChain([narration, 'optionalAccess', _124 => _124.words]), () => ( []))).map((w) => `${w.start} ${w.text}`).join("\n");
+  return (_nullishCoalesce(_optionalChain([narration, 'optionalAccess', _126 => _126.words]), () => ( []))).map((w) => `${w.start} ${w.text}`).join("\n");
 }
 function parseMotionNarration(text) {
   const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);