@pixerate/editor 0.232.0 → 0.233.0

package/dist/animation-editor/index.cjs

@@ -1,4 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2;
+
+
+
+
+var _chunk6RZVFYGJcjs = require('../chunk-6RZVFYGJ.cjs');
+
 
 var _chunkGXLZZVR5cjs = require('../chunk-GXLZZVR5.cjs');
 
@@ -8,7 +14,7 @@ var _chunkGXLZZVR5cjs = require('../chunk-GXLZZVR5.cjs');
 
 
 
-var _chunkERJA5CGTcjs = require('../chunk-ERJA5CGT.cjs');
+var _chunkDGWOGQJ5cjs = require('../chunk-DGWOGQJ5.cjs');
 
 
 
@@ -44,6 +50,10 @@ var _chunkGF2RBSDMcjs = require('../chunk-GF2RBSDM.cjs');
 require('../chunk-NM3G4VQT.cjs');
 
 
+var _chunkPY4GWSE2cjs = require('../chunk-PY4GWSE2.cjs');
+
+
+
 
 
 
@@ -54,7 +64,9 @@ require('../chunk-NM3G4VQT.cjs');
 
 
 
-var _chunk2K5TELHVcjs = require('../chunk-2K5TELHV.cjs');
+
+
+var _chunkJAOSL334cjs = require('../chunk-JAOSL334.cjs');
 require('../chunk-WOFXZ3XU.cjs');
 require('../chunk-PQ3H2AAN.cjs');
 require('../chunk-YQGCPL5X.cjs');
@@ -196,7 +208,10 @@ ${problems.map((p) => `- ${p}`).join("\n")}`);
   }
 };
 var SCENE_KEYS = ["version", "name", "description", "artwork", "shots", "clips", "drivers", "motionBlur", "loop", "trigger", "fps", "steps", "beat", "narration", "target", "controls", "presets"];
-var SHOT_KEYS = ["id", "label", "camera", "at", "run", "hold", "speed"];
+var SHOT_KEYS = ["id", "label", "camera", "at", "run", "hold", "speed", "layers", "transition"];
+var LAYER_KEYS = ["id", "effect", "preset", "values", "subject", "role", "rect", "from", "until", "opacity", "fade", "provider", "name"];
+var TRANSITION_KEYS = ["effect", "ms", "preset", "values", "provider", "name"];
+var LAYER_ID = /^[A-Za-z_][\w.-]*$/;
 var CAMERA_KEYS = ["x", "y", "width", "height", "frame", "padding", "ease", "ms", "geometric", "in", "during"];
 var CAMERA_MOVE_KEYS = ["move", "ms", "preset", "values"];
 var BASE_KEYS = ["type", "targets", "duration", "delay", "stagger", "with", "ease", "note", "repeat", "repeatMode", "steps", "split", "cascade", "source"];
@@ -228,14 +243,14 @@ var isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
 var isNum = (v) => typeof v === "number" && Number.isFinite(v);
 var isPoint = (v) => isObject(v) && isNum(v.x) && isNum(v.y);
 function unknownKeys(value, known, where, problems) {
-  for (const key of Object.keys(value)) if (!known.includes(key)) problems.push(`${where}: unknown field ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, key, known)}.`);
+  for (const key of Object.keys(value)) if (!known.includes(key)) problems.push(`${where}: unknown field ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, key, known)}.`);
 }
 function commandShapeProblems(command3, where) {
   const problems = [];
   if (!isObject(command3)) return [`${where} must be an object.`];
   const type = command3.type;
   if (typeof type !== "string" || !MOTION_COMMAND_TYPES.includes(type)) {
-    return [`${where}: unknown type ${typeof type === "string" ? _chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, type, MOTION_COMMAND_TYPES) : String(type)}; use one of ${MOTION_COMMAND_TYPES.join(", ")}.`];
+    return [`${where}: unknown type ${typeof type === "string" ? _chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, type, MOTION_COMMAND_TYPES) : String(type)}; use one of ${MOTION_COMMAND_TYPES.join(", ")}.`];
   }
   unknownKeys(command3, COMMAND_KEYS[type], `${where} (${type})`, problems);
   const p = (msg) => problems.push(`${where} (${type}): ${msg}`);
@@ -287,7 +302,7 @@ function commandShapeProblems(command3, where) {
     case "exit": {
       const styles = type === "enter" ? MOTION_ENTER_STYLES : MOTION_EXIT_STYLES;
       if (command3.style !== void 0 && !(typeof command3.style === "string" && styles.includes(command3.style)))
-        p(`"style" must be one of ${styles.join(", ")}${typeof command3.style === "string" ? ` (got ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, command3.style, styles)})` : ""}.`);
+        p(`"style" must be one of ${styles.join(", ")}${typeof command3.style === "string" ? ` (got ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, command3.style, styles)})` : ""}.`);
       if (command3.direction !== void 0 && !MOTION_DIRECTIONS.includes(command3.direction)) p(`"direction" must be one of ${MOTION_DIRECTIONS.join(", ")}.`);
       optionalNumber("distance");
       if (command3.scale !== void 0 && !(isNum(command3.scale) && command3.scale >= 0)) p(`"scale" must be a number \u2265 0 (the starting scale for pop and zoom).`);
@@ -466,6 +481,50 @@ function shotShapeProblems(shot, where) {
   }
   if (!Array.isArray(shot.run)) problems.push(`${name}: "run" must be a list of commands (it may be empty).`);
   else shot.run.forEach((command3, i) => problems.push(...commandShapeProblems(command3, `${name}, command ${i + 1}`)));
+  problems.push(...shotLayersShapeProblems(shot, name));
+  return problems;
+}
+var isLayerTime = (t) => isNum(t) && t >= 0 || isObject(t) && Object.keys(t).length === 1 && Number.isInteger(t.shots) && t.shots >= 1;
+function shotLayersShapeProblems(shot, name) {
+  const problems = [];
+  if (shot.layers !== void 0) {
+    if (!Array.isArray(shot.layers)) problems.push(`${name}: "layers" must be a list of layers.`);
+    else
+      shot.layers.forEach((layer, i) => {
+        const where = `${name}, layer ${i + 1}`;
+        if (!isObject(layer)) return void problems.push(`${where} must be an object.`);
+        unknownKeys(layer, LAYER_KEYS, where, problems);
+        if (typeof layer.id !== "string" || !LAYER_ID.test(layer.id)) problems.push(`${where}: "id" must be letters, digits, "_", "-" or "." (e.g. "layer1").`);
+        if (layer.effect === void 0 && layer.subject === void 0) problems.push(`${where} needs an "effect", a "subject" or both.`);
+        if (layer.effect !== void 0 && (typeof layer.effect !== "string" || !layer.effect)) problems.push(`${where}: "effect" must be an effect id.`);
+        if (layer.subject !== void 0) {
+          const kind = _chunk6RZVFYGJcjs.effectSubjectKind.call(void 0, layer.subject);
+          if (kind === "video") problems.push(`${where}: an animation layer cannot play a video; use { "image" }, { "svg" }, { "text" } or { "slot" } (the video editor plays video).`);
+          else if (!kind || !String(layer.subject[kind]).trim()) problems.push(`${where}: "subject" must be { "image": url }, { "svg": markup }, { "text": words } or { "slot": name }.`);
+        }
+        if (layer.role !== void 0 && !_chunkJAOSL334cjs.EFFECT_LAYER_ROLES.includes(layer.role)) problems.push(`${where}: "role" must be one of ${_chunkJAOSL334cjs.EFFECT_LAYER_ROLES.join(", ")}.`);
+        if (layer.rect !== void 0) {
+          const r = layer.rect;
+          if (!isObject(r) || !["x", "y", "width", "height"].every((k) => isNum(r[k])) || !(r.width > 0 && r.height > 0)) problems.push(`${where}: "rect" must be { x, y, width, height } in artwork units, width and height > 0.`);
+        }
+        for (const k of ["from", "until"]) if (layer[k] !== void 0 && !isLayerTime(layer[k])) problems.push(`${where}: "${k}" must be ms \u2265 0 after the shot starts, or { "shots": n } (n \u2265 1: when the n-th shot after this one starts).`);
+        if (layer.opacity !== void 0 && !(isNum(layer.opacity) && layer.opacity >= 0 && layer.opacity <= 1)) problems.push(`${where}: "opacity" must be a number from 0 to 1.`);
+        if (layer.fade !== void 0 && !(isNum(layer.fade) && layer.fade >= 0)) problems.push(`${where}: "fade" must be ms \u2265 0.`);
+        if (layer.preset !== void 0 && typeof layer.preset !== "string") problems.push(`${where}: "preset" is a preset's name.`);
+        if (layer.values !== void 0 && !isObject(layer.values)) problems.push(`${where}: "values" is an object of the effect's control values.`);
+        for (const k of ["provider", "name"]) if (layer[k] !== void 0 && typeof layer[k] !== "string") problems.push(`${where}: "${k}" must be a string.`);
+      });
+  }
+  if (shot.transition !== void 0) {
+    const t = shot.transition;
+    if (!isObject(t) || typeof t.effect !== "string" || !t.effect) problems.push(`${name}: "transition" is { "effect": id, "ms"?, "preset"?, "values"? }.`);
+    else {
+      unknownKeys(t, TRANSITION_KEYS, `${name} transition`, problems);
+      if (t.ms !== void 0 && !(isNum(t.ms) && t.ms > 0 && t.ms <= 6e4)) problems.push(`${name} transition: "ms" must be a number from 1 to 60000.`);
+      if (t.preset !== void 0 && typeof t.preset !== "string") problems.push(`${name} transition: "preset" is a preset's name.`);
+      if (t.values !== void 0 && !isObject(t.values)) problems.push(`${name} transition: "values" is an object of the effect's control values.`);
+    }
+  }
   return problems;
 }
 function motionSceneShapeProblems(input) {
@@ -494,8 +553,8 @@ function motionSceneShapeProblems(input) {
       problems.push('Scene: "beat" must be { "bpm": 1\u20131000, "offset"?: ms, "meter"?: beats a bar }.');
   }
   if (input.narration !== void 0) {
-    const n = input.narration;
-    if (!isObject(n) || !Array.isArray(n.words) || !n.words.every((w, i, all) => isObject(w) && typeof w.text === "string" && isNum(w.start) && w.start >= 0 && (w.end === void 0 || isNum(w.end) && w.end >= w.start) && (i === 0 || w.start >= (_nullishCoalesce(all[i - 1].start, () => ( 0))))))
+    const n2 = input.narration;
+    if (!isObject(n2) || !Array.isArray(n2.words) || !n2.words.every((w, i, all) => isObject(w) && typeof w.text === "string" && isNum(w.start) && w.start >= 0 && (w.end === void 0 || isNum(w.end) && w.end >= w.start) && (i === 0 || w.start >= (_nullishCoalesce(all[i - 1].start, () => ( 0))))))
       problems.push('Scene: "narration" must be { "words": [{ "text", "start": ms, "end"?: ms }, \u2026] } in time order.');
   }
   if (input.steps !== void 0 && !(isNum(input.steps) && input.steps > 0 && input.steps <= 120)) problems.push('Scene: "steps" must be frames per second from above 0 to 120.');
@@ -513,6 +572,17 @@ function motionSceneShapeProblems(input) {
     problems.push('Scene: "presets" must be a list of { name, values }.');
   if (!Array.isArray(input.shots)) problems.push('Scene: "shots" must be a list.');
   else input.shots.forEach((shot, i) => problems.push(...shotShapeProblems(shot, `Shot ${i + 1}`)));
+  if (Array.isArray(input.shots)) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const shot of input.shots)
+      if (isObject(shot) && Array.isArray(shot.layers)) {
+        for (const layer of shot.layers)
+          if (isObject(layer) && typeof layer.id === "string") {
+            if (seen.has(layer.id)) problems.push(`Layer id "${layer.id}" is used twice; layer ids are unique in the scene.`);
+            seen.add(layer.id);
+          }
+      }
+  }
   return problems;
 }
 function parseMotionScene(input) {
@@ -556,7 +626,7 @@ function matchMotionNodes(from, into) {
       for (const x of [...left]) {
         const k = key(x, a);
         if (!k) continue;
-        const y = [...right].find((n) => key(n, b) === k);
+        const y = [...right].find((n2) => key(n2, b) === k);
         if (!y) continue;
         left.delete(x);
         right.delete(y);
@@ -564,18 +634,18 @@ function matchMotionNodes(from, into) {
         else out.pairs.push([x.id, y.id]);
       }
     };
-    pair((n) => _optionalChain([n, 'access', _2 => _2.name, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]) || void 0);
-    pair((n, g) => localId(n.id, g.id) || void 0);
+    pair((n2) => _optionalChain([n2, 'access', _2 => _2.name, 'optionalAccess', _3 => _3.trim, 'call', _4 => _4()]) || void 0);
+    pair((n2, g) => localId(n2.id, g.id) || void 0);
     for (const x of [...left]) {
-      const y = [...right].find((n) => n.type === x.type);
+      const y = [...right].find((n2) => n2.type === x.type);
       if (!y) continue;
       left.delete(x);
       right.delete(y);
       if (x.type === "group" && y.type === "group") visit(x, y);
       else out.pairs.push([x.id, y.id]);
     }
-    out.unpairedFrom.push(...[...left].map((n) => n.id));
-    out.unpairedInto.push(...[...right].map((n) => n.id));
+    out.unpairedFrom.push(...[...left].map((n2) => n2.id));
+    out.unpairedInto.push(...[...right].map((n2) => n2.id));
   };
   visit(from, into);
   return out;
@@ -583,10 +653,10 @@ function matchMotionNodes(from, into) {
 
 // src/animation-editor/smooth.ts
 function smoothMotionLegs(times, values) {
-  const n = values.length;
-  const slope = new Array(n).fill(0);
+  const n2 = values.length;
+  const slope = new Array(n2).fill(0);
   const secant = (i) => (values[i + 1] - values[i]) / Math.max(1e-9, times[i + 1] - times[i]);
-  for (let i = 1; i < n - 1; i++) {
+  for (let i = 1; i < n2 - 1; i++) {
     const a = secant(i - 1);
     const b = secant(i);
     if (a * b <= 0) continue;
@@ -595,7 +665,7 @@ function smoothMotionLegs(times, values) {
     slope[i] = 3 * (ha + hb) / ((2 * hb + ha) / a + (hb + 2 * ha) / b);
   }
   const legs = [];
-  for (let i = 0; i + 1 < n; i++) {
+  for (let i = 0; i + 1 < n2; i++) {
     const dt = times[i + 1] - times[i];
     const dv = values[i + 1] - values[i];
     if (Math.abs(dv) < 1e-9) {
@@ -658,8 +728,8 @@ function motionTextUnits(layout, by) {
   return layout.lines.flatMap((l) => l.words.flatMap((w) => w.letters.map((id) => [id])));
 }
 function motionCascade(units, cascade = "forward", seed = 1) {
-  const n = units.length;
-  const mid = (n - 1) / 2;
+  const n2 = units.length;
+  const mid = (n2 - 1) / 2;
   const indexed = units.map((u, i) => ({ u, i }));
   if (cascade === "backward") return [...units].reverse();
   if (cascade === "center") return indexed.sort((a, b) => Math.abs(a.i - mid) - Math.abs(b.i - mid) || a.i - b.i).map((x) => x.u);
@@ -674,7 +744,7 @@ function motionCascade(units, cascade = "forward", seed = 1) {
       return ((t ^ t >>> 14) >>> 0) / 4294967296;
     };
     const out = [...units];
-    for (let i = n - 1; i > 0; i--) {
+    for (let i = n2 - 1; i > 0; i--) {
       const j = Math.floor(rand() * (i + 1));
       [out[i], out[j]] = [out[j], out[i]];
     }
@@ -739,12 +809,12 @@ function strokeReach(node) {
   return reach;
 }
 function motionRevealPadding(entry) {
-  const box = entry.box;
-  if (!box || !(box.width > 0) || !(box.height > 0)) return null;
+  const box2 = entry.box;
+  if (!box2 || !(box2.width > 0) || !(box2.height > 0)) return null;
   const s = strokeReach(entry.node);
-  return [Math.min(1, s / box.width + 0.02), Math.min(1, s / box.height + 0.02)];
+  return [Math.min(1, s / box2.width + 0.02), Math.min(1, s / box2.height + 0.02)];
 }
-var clipRound = (n) => Math.round(n * 1e4) / 1e4 || 0;
+var clipRound = (n2) => Math.round(n2 * 1e4) / 1e4 || 0;
 function revealFull(property, [px, py]) {
   return (property === "clipRect" ? [-px, -py, 1 + 2 * px, 1 + 2 * py] : [0.5, 0.5, Math.hypot(0.5 + px, 0.5 + py)]).map(clipRound);
 }
@@ -978,8 +1048,8 @@ function motionDriverSources(timeline, node, properties, seen = /* @__PURE__ */
 }
 function motionCommandRepeat(command3) {
   if (command3.type === "wait" || command3.type === "enter" || command3.type === "exit") return 1;
-  const n = _nullishCoalesce(command3.repeat, () => ( 1));
-  return Number.isInteger(n) && n >= 1 ? n : 1;
+  const n2 = _nullishCoalesce(command3.repeat, () => ( 1));
+  return Number.isInteger(n2) && n2 >= 1 ? n2 : 1;
 }
 function motionCommandDuration(command3, scene, target) {
   return motionCycleDuration(command3, scene, target) * motionCommandRepeat(command3);
@@ -1053,14 +1123,15 @@ function compileMotionScene(scene) {
     const start = t;
     let cursor = start;
     const f = motionShotTimeScale(shot);
-    const moveIn = shot.camera ? _chunk2K5TELHVcjs.cameraMoveParts.call(void 0, shot.camera.in) : void 0;
-    const moveDuring = shot.camera ? _chunk2K5TELHVcjs.cameraMoveParts.call(void 0, shot.camera.during) : void 0;
+    const moveIn = shot.camera ? _chunkJAOSL334cjs.cameraMoveParts.call(void 0, shot.camera.in) : void 0;
+    const transitionMs = index > 0 && shot.transition ? (_nullishCoalesce(shot.transition.ms, () => ( _chunkJAOSL334cjs.EFFECT_TRANSITION_MS))) * f : 0;
+    const moveDuring = shot.camera ? _chunkJAOSL334cjs.cameraMoveParts.call(void 0, shot.camera.during) : void 0;
     let playsIn = false;
     if (shot.camera) {
       const framed = motionCameraFramed(shot.camera);
       const rect = framed ? resolveMotionCamera(shot.camera, scene) : null;
       if (rect && rect.width > 0 && rect.height > 0 || !framed && moveIn) {
-        const ms2 = index === 0 ? 0 : (_nullishCoalesce(_nullishCoalesce(_optionalChain([moveIn, 'optionalAccess', _37 => _37.ms]), () => ( shot.camera.ms)), () => ( MOTION_CAMERA_MS))) * f;
+        const ms2 = index === 0 || transitionMs > 0 && !moveIn ? 0 : (_nullishCoalesce(_nullishCoalesce(_optionalChain([moveIn, 'optionalAccess', _37 => _37.ms]), () => ( shot.camera.ms)), () => ( MOTION_CAMERA_MS))) * f;
         cameraMoves.push({ shot: shot.id, start, end: start + ms2, to: rect, ease: _nullishCoalesce(shot.camera.ease, () => ( MOTION_EASE_IN_OUT)), geometric: shot.camera.geometric === true });
         cursor = start + ms2;
         playsIn = !!moveIn && index > 0;
@@ -1081,7 +1152,7 @@ function compileMotionScene(scene) {
       prevStart = begin;
       runEnd = Math.max(runEnd, end2);
     });
-    const end = runEnd + (_nullishCoalesce(shot.hold, () => ( MOTION_DEFAULT_HOLD))) * f;
+    const end = Math.max(runEnd, start + transitionMs) + (_nullishCoalesce(shot.hold, () => ( MOTION_DEFAULT_HOLD))) * f;
     shots.push({
       id: shot.id,
       index,
@@ -1093,7 +1164,8 @@ function compileMotionScene(scene) {
       ...cue !== void 0 ? { cue } : {},
       ...missedBy !== void 0 ? { missedBy } : {},
       ...playsIn ? { cameraIn: moveIn.move } : {},
-      ...moveDuring ? { cameraDuring: moveDuring.move } : {}
+      ...moveDuring ? { cameraDuring: moveDuring.move } : {},
+      ...transitionMs > 0 ? { transition: shot.transition.effect, transitionEnd: start + transitionMs } : {}
     });
     t = end;
   });
@@ -1157,14 +1229,14 @@ function compileMotionScene(scene) {
     const made = segments.slice(first);
     const steps = _nullishCoalesce(command3.steps, () => ( scene.steps));
     if (steps && steps > 0) for (const s of made) s.steps = steps;
-    const n = motionCommandRepeat(command3);
+    const n2 = motionCommandRepeat(command3);
     const mode = _nullishCoalesce(command3.repeatMode, () => ( "loop"));
     const shift = (v, by, k) => {
       if (typeof v === "number" && typeof by === "number") return v + by * k;
       if (Array.isArray(v) && Array.isArray(by) && v.length === by.length) return v.map((x, i) => x + by[i] * k);
       return v;
     };
-    for (let k = 1; k < n; k++) {
+    for (let k = 1; k < n2; k++) {
       const at = start + k * cycle;
       for (const s of made) {
         if (mode === "mirror" && k % 2 === 1) {
@@ -1422,7 +1494,7 @@ function motionShotAt(timeline, time) {
 // src/animation-editor/camera.ts
 var windowCache = /* @__PURE__ */ new WeakMap();
 function motionShotCameraMove(shot, role) {
-  return _chunk2K5TELHVcjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'optionalAccess', _55 => _55.camera, 'optionalAccess', _56 => _56[role === "transition" ? "in" : "during"]]));
+  return _chunkJAOSL334cjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'optionalAccess', _55 => _55.camera, 'optionalAccess', _56 => _56[role === "transition" ? "in" : "during"]]));
 }
 var motionCameraStage = (scene) => ({ width: scene.artwork.width, height: scene.artwork.height });
 var effectsPlayCamera = (provider) => !!provider && provider.capabilities.supportsCamera === true && typeof provider.cameraView === "function";
@@ -1444,7 +1516,7 @@ function motionCameraWindows(scene, provider) {
   const track = timeline.tracks.get(motionTrackKey("", "camera"));
   const boxView = (t) => {
     const b = trackValue(track, t);
-    return _chunk2K5TELHVcjs.cameraViewOfBox.call(void 0, Array.isArray(b) ? { x: b[0], y: b[1], width: b[2], height: b[3] } : full, stage);
+    return _chunkJAOSL334cjs.cameraViewOfBox.call(void 0, Array.isArray(b) ? { x: b[0], y: b[1], width: b[2], height: b[3] } : full, stage);
   };
   const view = (move, values, from, to, u, ms2) => {
     try {
@@ -1460,7 +1532,7 @@ function motionCameraWindows(scene, provider) {
     const eases = timing.commandsStart > timing.start && !!_optionalChain([track, 'optionalAccess', _57 => _57.some, 'call', _58 => _58((seg) => seg.shot === timing.id)]);
     const framed = !!_optionalChain([track, 'optionalAccess', _59 => _59.some, 'call', _60 => _60((seg) => seg.shot === timing.id)]);
     if (timing.cameraIn && timing.commandsStart > timing.start) {
-      const spec = _chunk2K5TELHVcjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'access', _61 => _61.camera, 'optionalAccess', _62 => _62.in]));
+      const spec = _chunkJAOSL334cjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'access', _61 => _61.camera, 'optionalAccess', _62 => _62.in]));
       const from = _nullishCoalesce(carry, () => ( boxView(timing.start)));
       const to = boxView(timing.commandsStart);
       if (view(spec.move, spec.values, from, to, 0, timing.commandsStart - timing.start)) {
@@ -1472,7 +1544,7 @@ function motionCameraWindows(scene, provider) {
       carry = null;
     } else if (framed) carry = null;
     if (timing.cameraDuring && timing.end > timing.commandsEnd) {
-      const spec = _chunk2K5TELHVcjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'access', _63 => _63.camera, 'optionalAccess', _64 => _64.during]));
+      const spec = _chunkJAOSL334cjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'access', _63 => _63.camera, 'optionalAccess', _64 => _64.during]));
       const from = _nullishCoalesce(carry, () => ( boxView(timing.commandsEnd)));
       const ms2 = timing.end - timing.commandsEnd;
       const last = view(spec.move, spec.values, from, from, 1, ms2);
@@ -1489,8 +1561,8 @@ var lerp = (a, b, t) => a + (b - a) * t;
 var smooth = (t) => t * t * (3 - 2 * t);
 function easeViews(from, to, u, stage) {
   const k = smooth(Math.min(1, Math.max(0, u)));
-  const a = _chunk2K5TELHVcjs.cameraBoxOfView.call(void 0, from, stage);
-  const b = _chunk2K5TELHVcjs.cameraBoxOfView.call(void 0, to, stage);
+  const a = _chunkJAOSL334cjs.cameraBoxOfView.call(void 0, from, stage);
+  const b = _chunkJAOSL334cjs.cameraBoxOfView.call(void 0, to, stage);
   const zoom = from.zoom * Math.pow(to.zoom / from.zoom, k);
   const cx = lerp(a.x + a.width / 2, b.x + b.width / 2, k);
   const cy = lerp(a.y + a.height / 2, b.y + b.height / 2, k);
@@ -1522,15 +1594,15 @@ function motionCameraViewAt(scene, time, provider) {
   return retaken ? null : before.after;
 }
 function motionCameraBox(view, scene) {
-  return _chunk2K5TELHVcjs.cameraBoxOfView.call(void 0, view, motionCameraStage(scene));
+  return _chunkJAOSL334cjs.cameraBoxOfView.call(void 0, view, motionCameraStage(scene));
 }
 function motionCameraTransform(view, width) {
   if (!view || !view.tilt && !view.turn) return "";
   const distance = (_nullishCoalesce(view.perspective, () => ( 2))) * width;
   return `perspective(${Math.round(distance)}px)${view.tilt ? ` rotateX(${round(view.tilt)}deg)` : ""}${view.turn ? ` rotateY(${round(-view.turn)}deg)` : ""}`;
 }
-var round = (n) => Math.round(n * 1e3) / 1e3;
-function withCameraViewEffects(svg, view, box, idPrefix = "vg-") {
+var round = (n2) => Math.round(n2 * 1e3) / 1e3;
+function withCameraViewEffects(svg, view, box2, idPrefix = "vg-") {
   if (!view || !view.roll && !(view.blur && view.blur > 0)) return svg;
   const open = svg.match(/<svg\b[^>]*>/);
   const close = svg.lastIndexOf("</svg>");
@@ -1538,7 +1610,7 @@ function withCameraViewEffects(svg, view, box, idPrefix = "vg-") {
   const startBody = open.index + open[0].length;
   const attrs = [];
   let defs = "";
-  if (view.roll) attrs.push(`transform="rotate(${round(view.roll)} ${round(box.x + box.width / 2)} ${round(box.y + box.height / 2)})"`);
+  if (view.roll) attrs.push(`transform="rotate(${round(view.roll)} ${round(box2.x + box2.width / 2)} ${round(box2.y + box2.height / 2)})"`);
   if (view.blur && view.blur > 0) {
     const s = view.blur / view.zoom / 2;
     const a = (_nullishCoalesce(view.blurAngle, () => ( 0))) * Math.PI / 180;
@@ -1555,7 +1627,7 @@ async function checkMotionCameraMoves(scene, provider) {
   if (!named.length) return issues;
   if (!effectsPlayCamera(provider)) {
     const ids = named.map((s) => `"${s.id}"`).join(", ");
-    issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "camera-move-not-played", `Shots ${ids} name camera moves, but ${provider ? `${provider.name} has no camera moves` : "no effects provider is set"}, so the camera eases between framings instead; set a provider with camera moves to play them.`));
+    issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "camera-move-not-played", `Shots ${ids} name camera moves, but ${provider ? `${provider.name} has no camera moves` : "no effects provider is set"}, so the camera eases between framings instead; set a provider with camera moves to play them.`));
     return issues;
   }
   for (const shot of named) {
@@ -1563,22 +1635,345 @@ async function checkMotionCameraMoves(scene, provider) {
       const spec = shot.camera[field];
       if (spec === void 0) continue;
       try {
-        await _chunk2K5TELHVcjs.resolveCameraMoveSpec.call(void 0, provider, spec, role);
+        await _chunkJAOSL334cjs.resolveCameraMoveSpec.call(void 0, provider, spec, role);
       } catch (error) {
         const code = error.code === "invalid_values" || /preset/.test(error.message) ? "camera-move-values" : "camera-move-unknown";
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, code, error.message, { shot: shot.id }));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, code, error.message, { shot: shot.id }));
       }
     }
   }
   return issues;
 }
 
+// src/animation-editor/layers.ts
+var spanCache = /* @__PURE__ */ new WeakMap();
+function motionLayerSpans(scene) {
+  const hit = spanCache.get(scene);
+  if (hit) return hit;
+  const timeline = compileMotionScene(scene);
+  const shots = timeline.shots;
+  const total = timeline.duration;
+  const at = (shotIndex2, t, fallback) => {
+    if (t === void 0) return fallback;
+    if (typeof t === "number") return shots[shotIndex2].start + t;
+    return _nullishCoalesce(_optionalChain([shots, 'access', _68 => _68[shotIndex2 + t.shots], 'optionalAccess', _69 => _69.start]), () => ( total));
+  };
+  const out = [];
+  scene.shots.forEach((shot, shotIndex2) => {
+    (_nullishCoalesce(shot.layers, () => ( []))).forEach((layer, index) => {
+      const start = at(shotIndex2, layer.from, shots[shotIndex2].start);
+      const end = Math.max(start, at(shotIndex2, _nullishCoalesce(layer.until, () => ( { shots: 1 })), total));
+      out.push({ layer, shot: shot.id, shotIndex: shotIndex2, index, role: _chunk6RZVFYGJcjs.effectLayerRole.call(void 0, layer), start, end });
+    });
+  });
+  spanCache.set(scene, out);
+  return out;
+}
+function motionLayersAt(scene, time) {
+  if (!scene.shots.some((s) => _optionalChain([s, 'access', _70 => _70.layers, 'optionalAccess', _71 => _71.length]))) return [];
+  const total = compileMotionScene(scene).duration;
+  const out = [];
+  for (const span of motionLayerSpans(scene)) {
+    if (time < span.start || time > span.end || time === span.end && span.end < total) continue;
+    const fade = _nullishCoalesce(span.layer.fade, () => ( 0));
+    const k = fade > 0 ? Math.min(1, (time - span.start) / fade, (span.end - time) / fade) : 1;
+    const opacity = Math.max(0, Math.min(1, (_nullishCoalesce(span.layer.opacity, () => ( 1))) * k));
+    if (opacity <= 0) continue;
+    out.push({ ...span, time: time - span.start, opacity });
+  }
+  return out;
+}
+function motionTransitionAt(scene, time) {
+  if (!scene.shots.some((s) => s.transition)) return null;
+  for (const s of compileMotionScene(scene).shots) {
+    if (s.transition && s.transitionEnd !== void 0 && time >= s.start && time < s.transitionEnd)
+      return { shot: s.id, shotIndex: s.index, effect: s.transition, start: s.start, end: s.transitionEnd, progress: (time - s.start) / (s.transitionEnd - s.start) };
+  }
+  return null;
+}
+var motionSceneHasLayers = (scene) => scene.shots.some((s) => _optionalChain([s, 'access', _72 => _72.layers, 'optionalAccess', _73 => _73.length]) || s.transition);
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var n = (v) => String(Math.round(v * 1e3) / 1e3);
+var box = (b) => `x="${n(b.x)}" y="${n(b.y)}" width="${n(b.width)}" height="${n(b.height)}"`;
+var svgDataUrl = (svg) => `data:image/svg+xml;charset=utf-8,${encodeURIComponent(svg)}`;
+function subjectSvg(subject, b, opacity, pictures) {
+  const o = opacity < 1 ? ` opacity="${n(opacity)}"` : "";
+  if ("image" in subject) {
+    const href = _nullishCoalesce(_optionalChain([pictures, 'optionalAccess', _74 => _74.subject, 'call', _75 => _75(subject)]), () => ( subject.image));
+    return `<image href="${esc(href)}" ${box(b)} preserveAspectRatio="xMidYMid meet"${o}/>`;
+  }
+  if ("svg" in subject) {
+    const href = subject.svg.trimStart().startsWith("<") ? svgDataUrl(subject.svg) : subject.svg;
+    return `<image href="${esc(href)}" ${box(b)} preserveAspectRatio="xMidYMid meet"${o}/>`;
+  }
+  if ("text" in subject) {
+    const size = Math.max(1, Math.min(b.height * 0.6, b.width / Math.max(1, subject.text.length) * 1.6));
+    return `<text x="${n(b.x + b.width / 2)}" y="${n(b.y + b.height / 2)}" text-anchor="middle" dominant-baseline="central" font-family="${esc(_nullishCoalesce(subject.font, () => ( "system-ui, sans-serif")))}" font-weight="${esc(String(_nullishCoalesce(subject.weight, () => ( 700))))}" font-size="${n(size)}" fill="#ffffff"${o}>${esc(subject.text)}</text>`;
+  }
+  return "";
+}
+function layerSvg(scene, active, camera, pictures) {
+  const b = _nullishCoalesce(active.layer.rect, () => ( camera));
+  if (!active.layer.effect) return active.layer.subject ? subjectSvg(active.layer.subject, b, active.opacity, pictures) : "";
+  const href = _optionalChain([pictures, 'optionalAccess', _76 => _76.layer, 'call', _77 => _77(scene, active, b)]);
+  if (!href) return "";
+  return `<image href="${esc(href)}" ${box(b)} preserveAspectRatio="none" data-layer="${esc(active.layer.id)}"${active.opacity < 1 ? ` opacity="${n(active.opacity)}"` : ""}/>`;
+}
+function withMotionShotLayers(svg, scene, time, camera, pictures, background) {
+  const active = motionLayersAt(scene, time);
+  const open = svg.indexOf(">") + 1;
+  let body = svg.slice(open, svg.lastIndexOf("</svg>"));
+  const defs = _nullishCoalesce(_optionalChain([/^\s*<defs>[\s\S]*?<\/defs>/, 'access', _78 => _78.exec, 'call', _79 => _79(body), 'optionalAccess', _80 => _80[0]]), () => ( ""));
+  body = body.slice(defs.length);
+  const bg = background && scene.artwork.background ? `<rect width="${n(scene.artwork.width)}" height="${n(scene.artwork.height)}" fill="${esc(scene.artwork.background)}"/>` : "";
+  const draw = (roles) => active.filter((a) => roles.includes(a.role)).map((a) => layerSvg(scene, a, camera, pictures)).join("");
+  return `${svg.slice(0, open)}${defs}${bg}${draw(["background"])}${body}${draw(["subject"])}${draw(["overlay"])}</svg>`;
+}
+function motionTransitionSvg(svg, from, active, camera, picture) {
+  const open = svg.indexOf(">") + 1;
+  if (picture) return `${svg.slice(0, open)}<image href="${esc(picture)}" ${box(camera)} preserveAspectRatio="none" data-transition="${esc(active.effect)}"/></svg>`;
+  const inner = svg.slice(open, svg.lastIndexOf("</svg>"));
+  const fromView = _nullishCoalesce(_optionalChain([/viewBox="([^"]*)"/, 'access', _81 => _81.exec, 'call', _82 => _82(from), 'optionalAccess', _83 => _83[1]]), () => ( ""));
+  const fromInner = from.slice(from.indexOf(">") + 1, from.lastIndexOf("</svg>"));
+  return `${svg.slice(0, open)}<svg ${box(camera)} viewBox="${fromView}" preserveAspectRatio="none" data-transition-from="">${fromInner}</svg><g opacity="${n(active.progress)}" data-transition-to="">${inner}</g></svg>`;
+}
+var sceneIds = /* @__PURE__ */ new WeakMap();
+var nextSceneId = 1;
+var sceneId = (scene) => {
+  let id = sceneIds.get(scene);
+  if (!id) sceneIds.set(scene, id = nextSceneId++);
+  return id;
+};
+var MotionLayersEngine = (_class = class {
+  
+  
+  
+  __init() {this.cache = /* @__PURE__ */ new Map()}
+  __init2() {this.pending = /* @__PURE__ */ new Map()}
+  __init3() {this.failures = /* @__PURE__ */ new Map()}
+  __init4() {this.descriptions = /* @__PURE__ */ new Map()}
+  __init5() {this.listeners = /* @__PURE__ */ new Set()}
+  
+  
+  __init6() {this.generation = 0}
+  
+  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.slot = _nullishCoalesce(options.slot, () => ( new (0, _chunkJAOSL334cjs.EffectsSlot)()));
+    this.host = _nullishCoalesce(options.host, () => ( null));
+    this.frameSvg = options.frameSvg;
+    this.options = { scale: _nullishCoalesce(options.scale, () => ( 1)), maxSize: _nullishCoalesce(options.maxSize, () => ( 1280)), fps: _nullishCoalesce(options.fps, () => ( 30)), maxEntries: _nullishCoalesce(options.maxEntries, () => ( 160)) };
+    this.pool = new (0, _chunkPY4GWSE2cjs.EffectRendererPool)({ maxRenderers: options.maxRenderers });
+    this.detach = this.slot.subscribe(() => {
+      this.reset();
+      this.notify();
+    });
+  }
+  get provider() {
+    return this.slot.provider;
+  }
+  /** Called when a picture is ready (draw the frame again). */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  /** Why pictures failed, newest last. */
+  failuresList() {
+    return [...this.failures.values()];
+  }
+  /** True while any picture is being made. */
+  get busy() {
+    return this.pending.size > 0;
+  }
+  /** Resolves once every picture asked for so far is made (or failed). */
+  async idle() {
+    while (this.pending.size) await Promise.all([...this.pending.values()]);
+  }
+  /** Forgets every picture and failure (a new provider, or the host changed). */
+  reset() {
+    this.generation++;
+    this.cache.clear();
+    this.pending.clear();
+    this.failures.clear();
+    this.descriptions.clear();
+    this.pool.clear();
+  }
+  dispose() {
+    this.detach();
+    this.reset();
+    this.listeners.clear();
+  }
+  notify() {
+    this.listeners.forEach((l) => l());
+  }
+  size(b) {
+    const k = Math.min(this.options.scale, this.options.maxSize / Math.max(b.width, b.height));
+    return { width: Math.max(1, Math.round(b.width * k)), height: Math.max(1, Math.round(b.height * k)) };
+  }
+  snap(t) {
+    const step = 1e3 / this.options.fps;
+    return Math.round(Math.round(t / step) * step * 1e3) / 1e3;
+  }
+  get(key) {
+    const v = this.cache.get(key);
+    if (v === void 0) return void 0;
+    this.cache.delete(key);
+    this.cache.set(key, v);
+    return v;
+  }
+  request(key, info2, work) {
+    if (this.cache.has(key) || this.pending.has(key) || this.failures.has(key)) return;
+    const generation = this.generation;
+    const run = work().then((url) => {
+      if (generation !== this.generation) return;
+      this.cache.set(key, url);
+      while (this.cache.size > this.options.maxEntries) this.cache.delete(this.cache.keys().next().value);
+    }).catch((error) => {
+      if (generation !== this.generation) return;
+      this.failures.set(key, { key, ...info2, error: error instanceof Error ? error : new Error(String(error)) });
+    }).finally(() => {
+      if (generation !== this.generation) return;
+      this.pending.delete(key);
+      this.notify();
+    });
+    this.pending.set(key, run);
+  }
+  describe(id) {
+    const provider = this.slot.require();
+    let d = this.descriptions.get(id);
+    if (!d) {
+      d = Promise.resolve(provider.describe(id));
+      this.descriptions.set(id, d);
+      d.catch(() => this.descriptions.delete(id));
+    }
+    return d;
+  }
+  subject(subject) {
+    if (subject.image.startsWith("data:")) return subject.image;
+    const host = this.host;
+    if (!host) return void 0;
+    const key = `img:${subject.image}`;
+    this.request(key, {}, () => host.loadImage(subject.image));
+    return this.get(key);
+  }
+  /** The pixels a layer's subject feeds its effect, at `size`. */
+  async subjectPixels(subject, size) {
+    const host = this.host;
+    const b = { x: 0, y: 0, ...size };
+    let s = subject;
+    if ("image" in s && !s.image.startsWith("data:")) s = { image: await host.loadImage(s.image) };
+    return host.rasterize(`<svg xmlns="http://www.w3.org/2000/svg" width="${size.width}" height="${size.height}" viewBox="0 0 ${size.width} ${size.height}">${subjectSvg(s, b, 1, void 0)}</svg>`, size.width, size.height);
+  }
+  layer(scene, active, b) {
+    const provider = this.slot.provider;
+    const host = this.host;
+    const layer = active.layer;
+    if (!provider || !host || !layer.effect) return void 0;
+    if (layer.subject && "slot" in layer.subject) return void 0;
+    const size = this.size(b);
+    const time = this.snap(active.time);
+    const key = `layer:${provider.id}:${layer.effect}:${JSON.stringify(_nullishCoalesce(layer.values, () => ( {})))}:${JSON.stringify(_nullishCoalesce(layer.subject, () => ( null)))}:${size.width}x${size.height}@${time}`;
+    const effect = layer.effect;
+    this.request(key, { layer: layer.id }, async () => {
+      const d = await this.describe(effect);
+      const values = _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, layer.values);
+      const input = _chunk6RZVFYGJcjs.effectLayerInput.call(void 0, d);
+      const inputs = layer.subject && input ? { [input]: await this.subjectPixels(layer.subject, size) } : void 0;
+      const pixels = await this.pool.render(provider, effect, size, { time, values, ...inputs ? { inputs } : {} });
+      return host.encode(pixels);
+    });
+    return this.get(key);
+  }
+  transition(scene, time, active) {
+    const provider = this.slot.provider;
+    const host = this.host;
+    const frameSvg = this.frameSvg;
+    if (!provider || !host || !frameSvg) return void 0;
+    const shot = scene.shots[active.shotIndex];
+    const t = shot.transition;
+    const size = this.size({ x: 0, y: 0, width: scene.artwork.width, height: scene.artwork.height });
+    const at = Math.min(active.end - 1e-3, this.snap(time));
+    const progress = (at - active.start) / (active.end - active.start);
+    const key = `transition:${sceneId(scene)}:${provider.id}:${t.effect}:${JSON.stringify(_nullishCoalesce(t.values, () => ( {})))}:${size.width}x${size.height}@${at}`;
+    const fromKey = `from:${sceneId(scene)}:${active.shot}:${size.width}x${size.height}`;
+    this.request(key, { transition: active.shot }, async () => {
+      const d = await this.describe(t.effect);
+      const values = _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, t.values);
+      frameSvg(scene, Math.max(0, active.start - 1e-3));
+      frameSvg(scene, at);
+      await this.idleExcept(key);
+      const fromSvg = frameSvg(scene, Math.max(0, active.start - 1e-3));
+      const toSvg = frameSvg(scene, at);
+      let from = this.fromPixels.get(fromKey);
+      if (!from) {
+        from = host.rasterize(fromSvg, size.width, size.height);
+        this.fromPixels.set(fromKey, from);
+        if (this.fromPixels.size > 8) this.fromPixels.delete(this.fromPixels.keys().next().value);
+      }
+      const to = await host.rasterize(toSvg, size.width, size.height);
+      const pixels = await this.pool.render(provider, t.effect, size, { time: at - active.start, progress, values, inputs: { from: await from, to } });
+      return host.encode(pixels);
+    });
+    return this.get(key);
+  }
+  __init7() {this.fromPixels = /* @__PURE__ */ new Map()}
+  async idleExcept(key) {
+    for (; ; ) {
+      const others = [...this.pending].filter(([k]) => k !== key && !k.startsWith("transition:")).map(([, p]) => p);
+      if (!others.length) return;
+      await Promise.all(others);
+    }
+  }
+}, _class);
+function browserMotionLayerHost(doc = globalThis.document) {
+  const view = _optionalChain([doc, 'optionalAccess', _84 => _84.defaultView]);
+  if (!doc || !_optionalChain([view, 'optionalAccess', _85 => _85.Image]) || typeof doc.createElement !== "function") return null;
+  const canvas = (width, height) => {
+    const c = doc.createElement("canvas");
+    c.width = width;
+    c.height = height;
+    const ctx = c.getContext("2d");
+    if (!ctx) throw new Error("This browser cannot draw layer pictures (no 2D canvas).");
+    return { c, ctx };
+  };
+  const load = (src, cors) => new Promise((resolve2, reject) => {
+    const image = new view.Image();
+    if (cors) image.crossOrigin = "anonymous";
+    image.onload = () => resolve2(image);
+    image.onerror = () => reject(new Error(`The picture ${src.startsWith("data:") ? "(a data: URL)" : `"${src}"`} could not be loaded; check the URL and that its server allows cross-origin use.`));
+    image.src = src;
+  });
+  return {
+    async rasterize(svg, width, height) {
+      const image = await load(svgDataUrl(svg), false);
+      const { ctx } = canvas(width, height);
+      ctx.drawImage(image, 0, 0, width, height);
+      const data = ctx.getImageData(0, 0, width, height);
+      return { width, height, data: data.data };
+    },
+    encode(pixels) {
+      const { c, ctx } = canvas(pixels.width, pixels.height);
+      const image = ctx.createImageData(pixels.width, pixels.height);
+      image.data.set(pixels.data);
+      ctx.putImageData(image, 0, 0);
+      return c.toDataURL("image/png");
+    },
+    async loadImage(url) {
+      if (url.startsWith("data:")) return url;
+      const image = await load(url, true);
+      const { c, ctx } = canvas(image.naturalWidth || 1, image.naturalHeight || 1);
+      ctx.drawImage(image, 0, 0);
+      return c.toDataURL("image/png");
+    }
+  };
+}
+var motionLayerSlot = (layer) => layer.subject && "slot" in layer.subject ? layer.subject.slot : void 0;
+
 // src/animation-editor/evaluate.ts
 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', _68 => _68.controls, 'optionalAccess', _69 => _69.length])) return scene;
+  if (!values || !_optionalChain([scene, 'access', _86 => _86.controls, 'optionalAccess', _87 => _87.length])) return scene;
   const map = /* @__PURE__ */ new Map();
   for (const control of scene.controls) {
     const value = values[control.name];
@@ -1625,7 +2020,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', _70 => _70.length])) return null;
+  if (!_optionalChain([track, 'optionalAccess', _88 => _88.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;
@@ -1648,8 +2043,8 @@ function motionFollowRoute(entry, path) {
 }
 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', _71 => _71[0]])));
-  if (!_optionalChain([s, 'optionalAccess', _72 => _72.path])) return null;
+  const s = _nullishCoalesce(activeSegment(track, time), () => ( _optionalChain([track, 'optionalAccess', _89 => _89[0]])));
+  if (!_optionalChain([s, 'optionalAccess', _90 => _90.path])) return null;
   const route = motionFollowRoute(entry, nodes.get(s.path));
   const progress = Number(trackValue(track, time));
   if (!route || !(progress >= 0)) return null;
@@ -1667,7 +2062,7 @@ function motionNodeOffset(entry, timeline, time, nodes = indexMotionNodes([entry
     const layered = withMotionLayers(timeline, entry.node.id, p, typeof v === "number" ? v : rest, time, raw);
     return p === "follow" ? layered : applyMotionDrivers(timeline, entry.node.id, p, layered, time, raw);
   };
-  const driven = _optionalChain([timeline, 'access', _73 => _73.drivers, 'optionalAccess', _74 => _74.some, 'call', _75 => _75((d) => d.target === entry.node.id && d.property !== "opacity")]);
+  const driven = _optionalChain([timeline, 'access', _91 => _91.drivers, 'optionalAccess', _92 => _92.some, 'call', _93 => _93((d) => d.target === entry.node.id && d.property !== "opacity")]);
   if (!driven && !TRANSFORM_PROPS.some((p) => (follow || p !== "follow") && (timeline.tracks.has(motionTrackKey(entry.node.id, p)) || timeline.tracks.has(motionAddTrackKey(entry.node.id, p))))) return null;
   const dx = read("x", 0);
   const dy = read("y", 0);
@@ -1711,7 +2106,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', _76 => _76.effects, 'optionalAccess', _77 => _77.length])) {
+    if (effectTracks.length && _optionalChain([out, 'access', _94 => _94.effects, 'optionalAccess', _95 => _95.length])) {
       out = {
         ...out,
         effects: out.effects.map((effect) => {
@@ -1751,7 +2146,7 @@ function motionFrameAt(scene, time, options = {}) {
         return p;
       });
     }
-    const opacity = _optionalChain([timeline, 'access', _78 => _78.drivers, 'optionalAccess', _79 => _79.some, 'call', _80 => _80((d) => d.target === id && d.property === "opacity")]) ? motionPropertyValue(timeline, id, "opacity", time) : value(id, "opacity");
+    const opacity = _optionalChain([timeline, 'access', _96 => _96.drivers, 'optionalAccess', _97 => _97.some, 'call', _98 => _98((d) => d.target === id && d.property === "opacity")]) ? motionPropertyValue(timeline, id, "opacity", time) : value(id, "opacity");
     if (typeof opacity === "number") {
       const o = Math.min(1, Math.max(0, tidy(opacity)));
       out = { ...out, opacity: o };
@@ -1767,8 +2162,8 @@ function motionFrameAt(scene, time, options = {}) {
   const document = { ...s.artwork, nodes: s.artwork.nodes.map(visit) };
   const cam = trackValue(timeline.tracks.get(motionTrackKey("", "camera")), time);
   const view = motionCameraViewAt(s, time, options.effects);
-  const box = view ? (({ x, y, width, height }) => [x, y, width, height])(motionCameraBox(view, s)) : Array.isArray(cam) ? cam : [0, 0, s.artwork.width, s.artwork.height];
-  return { time, document, camera: { x: tidy(box[0]), y: tidy(box[1]), width: tidy(box[2]), height: tidy(box[3]) }, ...view ? { view } : {}, clips };
+  const box2 = view ? (({ x, y, width, height }) => [x, y, width, height])(motionCameraBox(view, s)) : Array.isArray(cam) ? cam : [0, 0, s.artwork.width, s.artwork.height];
+  return { time, document, camera: { x: tidy(box2[0]), y: tidy(box2[1]), width: tidy(box2[2]), height: tidy(box2[3]) }, ...view ? { view } : {}, clips };
 }
 function motionClipAttrs(clip) {
   const { shape: _shape, ...attrs } = clip;
@@ -1780,11 +2175,20 @@ function motionFrameToSvg(scene, time, options = {}) {
   const wrap = { ...options.wrap };
   for (const [id, clips] of Object.entries(frame.clips))
     wrap[id] = [..._nullishCoalesce(wrap[id], () => ( [])), ...clips.map((clip, i) => ({ clip: { id: `${prefix}reveal-${id}-${i}`, shape: clip.shape, attrs: motionClipAttrs(clip) } }))];
-  return withCameraViewEffects(withViewBox(_chunkBQE3Y6ZOcjs.vectorDocumentToSvg.call(void 0, frame.document, { ...options, wrap }), frame.camera), frame.view, frame.camera, prefix);
+  if (!motionSceneHasLayers(scene)) return withCameraViewEffects(withViewBox(_chunkBQE3Y6ZOcjs.vectorDocumentToSvg.call(void 0, frame.document, { ...options, wrap }), frame.camera), frame.view, frame.camera, prefix);
+  const art = _chunkBQE3Y6ZOcjs.vectorDocumentToSvg.call(void 0, frame.document, { ...options, wrap, background: false });
+  let svg = withViewBox(withMotionShotLayers(art, scene, time, frame.camera, options.layers, options.background !== false), frame.camera);
+  const transition = options.transitions === false ? null : motionTransitionAt(scene, time);
+  if (transition) {
+    const picture = _optionalChain([options, 'access', _99 => _99.layers, 'optionalAccess', _100 => _100.transition, 'call', _101 => _101(scene, time, transition)]);
+    const from = picture ? "" : motionFrameToSvg(scene, Math.max(0, transition.start - 1e-3), { ...options, transitions: false, idPrefix: `${prefix}from-` });
+    svg = motionTransitionSvg(svg, from, transition, frame.camera, picture);
+  }
+  return withCameraViewEffects(svg, frame.view, frame.camera, prefix);
 }
-function withViewBox(svg, box) {
-  const f = (n) => String(Math.round(n * 1e3) / 1e3);
-  return svg.replace(/viewBox="[^"]*"/, `viewBox="${f(box.x)} ${f(box.y)} ${f(box.width)} ${f(box.height)}"`);
+function withViewBox(svg, box2) {
+  const f = (n2) => String(Math.round(n2 * 1e3) / 1e3);
+  return svg.replace(/viewBox="[^"]*"/, `viewBox="${f(box2.x)} ${f(box2.y)} ${f(box2.width)} ${f(box2.height)}"`);
 }
 
 // src/animation-editor/onion.ts
@@ -1822,10 +2226,10 @@ function motionPath(scene, id, options = {}) {
   const to = Math.min(timeline.duration, _nullishCoalesce(options.to, () => ( timeline.duration)));
   let step = options.step && options.step > 0 ? options.step : 1e3 / 30;
   if ((to - from) / step > 400) step = (to - from) / 400;
-  const r = (n) => Math.round(n * 100) / 100;
+  const r = (n2) => Math.round(n2 * 100) / 100;
   const centreAt = (t) => {
     const node = indexMotionNodes(motionFrameAtCache(scene, t)).get(id);
-    const b = _optionalChain([node, 'optionalAccess', _81 => _81.bounds]);
+    const b = _optionalChain([node, 'optionalAccess', _102 => _102.bounds]);
     return b ? { t: r(t), x: r(b.x + b.width / 2), y: r(b.y + b.height / 2) } : null;
   };
   const points = [];
@@ -1843,7 +2247,7 @@ function motionFrameAtCache(scene, t) {
 }
 function motionPathsSvg(paths, camera, color = "#f43f5e") {
   const w = Math.max(camera.width, camera.height) / 400;
-  const f = (n) => String(Math.round(n * 100) / 100);
+  const f = (n2) => String(Math.round(n2 * 100) / 100);
   return paths.filter((p) => p.points.length > 1).map(
     (p) => `<g data-motion-path="${p.id.replace(/"/g, "&quot;")}" fill="none" stroke="${color}" stroke-width="${f(w)}" stroke-linecap="round" stroke-linejoin="round" opacity="0.8"><polyline points="${p.points.map((q) => `${f(q.x)},${f(q.y)}`).join(" ")}" stroke-dasharray="${f(w * 3)} ${f(w * 2)}"/>${p.keys.map((k) => `<circle cx="${f(k.x)}" cy="${f(k.y)}" r="${f(w * 2.5)}" fill="${color}" stroke="none"/>`).join("")}</g>`
   ).join("");
@@ -1859,22 +2263,22 @@ function motionBlurTimes(scene, time, blur = {}) {
   const b = indexMotionNodes(motionFrameAt(scene, time + span / 2).document.nodes);
   let travel = 0;
   for (const id of ids) {
-    const p = _optionalChain([a, 'access', _82 => _82.get, 'call', _83 => _83(id), 'optionalAccess', _84 => _84.bounds]);
-    const q = _optionalChain([b, 'access', _85 => _85.get, 'call', _86 => _86(id), 'optionalAccess', _87 => _87.bounds]);
+    const p = _optionalChain([a, 'access', _103 => _103.get, 'call', _104 => _104(id), 'optionalAccess', _105 => _105.bounds]);
+    const q = _optionalChain([b, 'access', _106 => _106.get, 'call', _107 => _107(id), 'optionalAccess', _108 => _108.bounds]);
     if (p && q) travel = Math.max(travel, Math.abs(p.x - q.x), Math.abs(p.y - q.y), Math.abs(p.x + p.width - q.x - q.width), Math.abs(p.y + p.height - q.y - q.height));
   }
-  const n = Math.min(most, Math.ceil(travel / 1.5));
-  if (n <= 1) return [time];
-  return Array.from({ length: n }, (_, k) => time - span / 2 + span * (k + 0.5) / n);
+  const n2 = Math.min(most, Math.ceil(travel / 1.5));
+  if (n2 <= 1) return [time];
+  return Array.from({ length: n2 }, (_, k) => time - span / 2 + span * (k + 0.5) / n2);
 }
 function averagedFrames(scene, times, options, prefix) {
-  const n = times.length;
-  return `<g data-motion-blur="${n}" style="isolation:isolate">${times.map((t, k) => {
+  const n2 = times.length;
+  return `<g data-motion-blur="${n2}" style="isolation:isolate">${times.map((t, k) => {
     const own = `${prefix}blur${k}-`;
     const frame = motionFrameToSvg(scene, t, { ...options, idPrefix: own, background: false });
-    const view = _nullishCoalesce(_optionalChain([/viewBox="([^"]*)"/, 'access', _88 => _88.exec, 'call', _89 => _89(frame), 'optionalAccess', _90 => _90[1]]), () => ( ""));
-    const inner = k === n - 1 ? innerSvg(frame) : innerSvg(frame).replace(new RegExp(` id="(?!${own.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})[^"]*"`, "g"), "");
-    return `<svg viewBox="${view}" preserveAspectRatio="none" style="mix-blend-mode:plus-lighter" opacity="${Math.round(1e4 / n) / 1e4}">${inner}</svg>`;
+    const view = _nullishCoalesce(_optionalChain([/viewBox="([^"]*)"/, 'access', _109 => _109.exec, 'call', _110 => _110(frame), 'optionalAccess', _111 => _111[1]]), () => ( ""));
+    const inner = k === n2 - 1 ? innerSvg(frame) : innerSvg(frame).replace(new RegExp(` id="(?!${own.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})[^"]*"`, "g"), "");
+    return `<svg viewBox="${view}" preserveAspectRatio="none" style="mix-blend-mode:plus-lighter" opacity="${Math.round(1e4 / n2) / 1e4}">${inner}</svg>`;
   }).join("")}</g>`;
 }
 var innerSvg = (svg) => svg.slice(svg.indexOf(">") + 1, svg.lastIndexOf("</svg>"));
@@ -1887,7 +2291,7 @@ function motionStageSvg(scene, time, options = {}) {
   if (blurTimes.length > 1) {
     const open2 = current.indexOf(">") + 1;
     const body2 = current.slice(open2, current.lastIndexOf("</svg>"));
-    const bg2 = svgOptions.background !== false && scene.artwork.background ? _nullishCoalesce(_optionalChain([/^\s*<rect[^>]*\/>/, 'access', _91 => _91.exec, 'call', _92 => _92(body2), 'optionalAccess', _93 => _93[0]]), () => ( "")) : "";
+    const bg2 = svgOptions.background !== false && scene.artwork.background ? _nullishCoalesce(_optionalChain([/^\s*<rect[^>]*\/>/, 'access', _112 => _112.exec, 'call', _113 => _113(body2), 'optionalAccess', _114 => _114[0]]), () => ( "")) : "";
     current = `${current.slice(0, open2)}${bg2}${averagedFrames(scene, blurTimes, svgOptions, prefix)}</svg>`;
   }
   if (!onionSkin && !motionPaths) return current;
@@ -1902,14 +2306,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', _94 => _94.exec, 'call', _95 => _95(body), 'optionalAccess', _96 => _96[0]]), () => ( "")) : "";
+  const bg = svgOptions.background !== false && scene.artwork.background ? _nullishCoalesce(_optionalChain([/^\s*<rect[^>]*\/>/, 'access', _115 => _115.exec, 'call', _116 => _116(body), 'optionalAccess', _117 => _117[0]]), () => ( "")) : "";
   return `${current.slice(0, open)}${bg}${ghosts.join("")}${body.slice(bg.length)}${paths}</svg>`;
 }
 function motionContactSheetSvg(scene, times, options = {}) {
   const { columns, labels = true, ...frameOptions } = options;
-  const n = Math.max(1, times.length);
-  const cols = Math.max(1, Math.min(n, Math.floor(_nullishCoalesce(columns, () => ( Math.ceil(Math.sqrt(n)))))));
-  const rows = Math.ceil(n / cols);
+  const n2 = Math.max(1, times.length);
+  const cols = Math.max(1, Math.min(n2, Math.floor(_nullishCoalesce(columns, () => ( Math.ceil(Math.sqrt(n2)))))));
+  const rows = Math.ceil(n2 / cols);
   const { width: w, height: h } = scene.artwork;
   const gap = Math.round(Math.max(w, h) * 0.04);
   const label = labels ? Math.round(Math.max(12, h * 0.08)) : 0;
@@ -1921,7 +2325,7 @@ function motionContactSheetSvg(scene, times, options = {}) {
     const x = gap + i % cols * (w + gap);
     const y = gap + Math.floor(i / cols) * (h + label + gap);
     const frame = motionStageSvg(scene, t, { ...frameOptions, idPrefix: `${prefix}f${i}-` });
-    const view = _nullishCoalesce(_optionalChain([/viewBox="([^"]*)"/, 'access', _97 => _97.exec, 'call', _98 => _98(frame), 'optionalAccess', _99 => _99[1]]), () => ( `0 0 ${w} ${h}`));
+    const view = _nullishCoalesce(_optionalChain([/viewBox="([^"]*)"/, 'access', _118 => _118.exec, 'call', _119 => _119(frame), 'optionalAccess', _120 => _120[1]]), () => ( `0 0 ${w} ${h}`));
     const inner = innerSvg(frame).replace(new RegExp(` id="(?!${`${prefix}f${i}-`.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})[^"]*"`, "g"), "");
     const shot = _nullishCoalesce(timeline.shots.find((s) => t >= s.start && t < s.end), () => ( timeline.shots[timeline.shots.length - 1]));
     const caption = labels ? `<text x="${x + w / 2}" y="${y + h + label * 0.8}" font-family="system-ui, sans-serif" font-size="${Math.round(label * 0.7)}" text-anchor="middle" fill="#64748b">${(t / 1e3).toFixed(2)} s${shot ? ` \xB7 ${shot.id.replace(/[<&]/g, "")}` : ""}</text>` : "";
@@ -1933,7 +2337,7 @@ function motionContactSheetSvg(scene, times, options = {}) {
 // src/animation-editor/check.ts
 var MOTION_MIN_CHANGE_MS = 120;
 var NUMERIC_PARAMS = (node, effectId) => {
-  const effect = _optionalChain([node, 'access', _100 => _100.effects, 'optionalAccess', _101 => _101.find, 'call', _102 => _102((e) => e.id === effectId)]);
+  const effect = _optionalChain([node, 'access', _121 => _121.effects, 'optionalAccess', _122 => _122.find, 'call', _123 => _123((e) => e.id === effectId)]);
   if (!effect) return null;
   return Object.entries(effect.params).filter(([, v]) => typeof v === "number").map(([k]) => k);
 };
@@ -1976,97 +2380,97 @@ function checkMotionScene(scene) {
   const ids = [...nodes.keys()];
   const timeline = compileMotionScene(scene);
   const artAspect = scene.artwork.width / scene.artwork.height;
-  if (!scene.shots.length) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "no-shots", "The scene has no shots yet; add one with a list of commands."));
+  if (!scene.shots.length) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "no-shots", "The scene has no shots yet; add one with a list of commands."));
   const seen = /* @__PURE__ */ new Set();
   for (const shot of scene.shots) {
-    if (seen.has(shot.id)) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "duplicate-shot-id", `Shot id "${shot.id}" is used twice; give each shot its own id.`, { shot: shot.id }));
+    if (seen.has(shot.id)) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "duplicate-shot-id", `Shot id "${shot.id}" is used twice; give each shot its own id.`, { shot: shot.id }));
     seen.add(shot.id);
   }
   const known = (id, code, what, where) => {
     if (nodes.has(id)) return true;
-    issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, code, `There is no ${what} ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, ids)} in the artwork${ids.length ? "" : " (it has no nodes yet)"}.`, { ...where, ids: [id] }));
+    issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, code, `There is no ${what} ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, ids)} in the artwork${ids.length ? "" : " (it has no nodes yet)"}.`, { ...where, ids: [id] }));
     return false;
   };
   scene.shots.forEach((shot, shotIndex2) => {
     if (shot.camera && "frame" in shot.camera && typeof shot.camera.frame === "string") known(shot.camera.frame, "unknown-frame", "node to frame", { shot: shot.id });
     else if (shot.camera && motionCameraFramed(shot.camera)) {
       const c = shot.camera;
-      if (!(c.width > 0 && c.height > 0)) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "invalid-camera", `The camera needs a positive width and height (got ${c.width} \xD7 ${c.height}).`, { shot: shot.id }));
+      if (!(c.width > 0 && c.height > 0)) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "invalid-camera", `The camera needs a positive width and height (got ${c.width} \xD7 ${c.height}).`, { shot: shot.id }));
       else if (Math.abs(c.width / c.height / artAspect - 1) > 0.02)
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "camera-aspect", `The camera is ${c.width} \xD7 ${c.height}, a different shape from the ${scene.artwork.width} \xD7 ${scene.artwork.height} artwork, so it shows bands at the sides; frame a node instead to match.`, { shot: shot.id }));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "camera-aspect", `The camera is ${c.width} \xD7 ${c.height}, a different shape from the ${scene.artwork.width} \xD7 ${scene.artwork.height} artwork, so it shows bands at the sides; frame a node instead to match.`, { shot: shot.id }));
     }
-    if (shotIndex2 === 0 && _optionalChain([shot, 'access', _103 => _103.camera, 'optionalAccess', _104 => _104.in]) !== void 0) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "camera-move-first-shot", 'The first shot cuts to its framing (there is none before it to move from), so its camera "in" does not play; put the move on the next shot, or use a "during" move here.', { shot: shot.id }));
-    if (!shot.run.length && !shot.camera && shotIndex2 > 0) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "empty-shot", "This shot only holds; add commands or a camera move, or remove it.", { shot: shot.id }));
+    if (shotIndex2 === 0 && _optionalChain([shot, 'access', _124 => _124.camera, 'optionalAccess', _125 => _125.in]) !== void 0) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "camera-move-first-shot", 'The first shot cuts to its framing (there is none before it to move from), so its camera "in" does not play; put the move on the next shot, or use a "during" move here.', { shot: shot.id }));
+    if (!shot.run.length && !shot.camera && shotIndex2 > 0) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "empty-shot", "This shot only holds; add commands or a camera move, or remove it.", { shot: shot.id }));
     shot.run.forEach((command3, i) => {
       const where = { shot: shot.id, command: i };
       if (command3.type === "wait") return;
       const targets = command3.targets.filter((id) => known(id, "unknown-target", "node", where));
       const timing = timeline.commands.find((c) => c.shot === shot.id && c.command === i);
       if (timing && timing.duration > 0 && timing.duration < MOTION_MIN_CHANGE_MS)
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "too-fast", `This ${command3.type} lasts ${timing.duration} ms, too quick to follow; make it at least ${MOTION_MIN_CHANGE_MS} ms.`, { ...where, measured: timing.duration, needed: MOTION_MIN_CHANGE_MS, unit: "ms", ids: targets }));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "too-fast", `This ${command3.type} lasts ${timing.duration} ms, too quick to follow; make it at least ${MOTION_MIN_CHANGE_MS} ms.`, { ...where, measured: timing.duration, needed: MOTION_MIN_CHANGE_MS, unit: "ms", ids: targets }));
       if (command3.duration !== void 0 && command3.ease !== void 0) {
         const ease = _chunkDWJJI6RTcjs.resolveEasing.call(void 0, command3.ease);
         if (ease !== "hold" && ease.type === "spring") {
           const settle = _chunkDWJJI6RTcjs.springSettleMs.call(void 0, ease);
           if (command3.duration < settle * 0.9)
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "spring-cut-short", `This ${command3.type}'s spring takes ${settle} ms to settle but lasts ${command3.duration} ms, so it jumps to its end; leave "duration" out (the spring sets it) or make it at least ${settle} ms.`, { ...where, measured: command3.duration, needed: settle, unit: "ms", ids: targets }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "spring-cut-short", `This ${command3.type}'s spring takes ${settle} ms to settle but lasts ${command3.duration} ms, so it jumps to its end; leave "duration" out (the spring sets it) or make it at least ${settle} ms.`, { ...where, measured: command3.duration, needed: settle, unit: "ms", ids: targets }));
         }
       }
       if (command3.type === "follow" && known(command3.path, "unknown-path", "path", where) && nodes.get(command3.path).node.type !== "path")
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "not-a-path", `"${command3.path}" is a group; follow a single path node.`, { ...where, ids: [command3.path] }));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "not-a-path", `"${command3.path}" is a group; follow a single path node.`, { ...where, ids: [command3.path] }));
       if (command3.type === "morph") known(command3.into, "unknown-shape", "shape", where);
       if (command3.type !== "play" && command3.split) {
         for (const id of targets)
           if (!motionTextLayout(nodes, id))
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "split-not-text", `"${id}" is not a group of letter paths, so "split": "${command3.split}" animates it as a whole; convert the text to outlines and group the letters (get_text_layout shows how they read).`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "split-not-text", `"${id}" is not a group of letter paths, so "split": "${command3.split}" animates it as a whole; convert the text to outlines and group the letters (get_text_layout shows how they read).`, { ...where, ids: [id] }));
       }
-      if (command3.type === "play" && !_optionalChain([scene, 'access', _105 => _105.clips, 'optionalAccess', _106 => _106[command3.clip]]))
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-clip", `There is no clip ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, command3.clip, Object.keys(_nullishCoalesce(scene.clips, () => ( {}))))}; define it with set_animation_clip.`, where));
+      if (command3.type === "play" && !_optionalChain([scene, 'access', _126 => _126.clips, 'optionalAccess', _127 => _127[command3.clip]]))
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-clip", `There is no clip ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, command3.clip, Object.keys(_nullishCoalesce(scene.clips, () => ( {}))))}; define it with set_animation_clip.`, where));
       if (command3.type === "match" && known(command3.into, "unknown-shape", "group", where)) {
         const into = nodes.get(command3.into);
         for (const id of targets) {
           const entry = nodes.get(id);
           if (id === command3.into || into.ancestors.includes(id) || entry.ancestors.includes(command3.into)) {
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "match-self", `"${id}" cannot match "${command3.into}": one is the other or holds it. Match two separate groups (the second usually hidden).`, { ...where, ids: [id, command3.into] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "match-self", `"${id}" cannot match "${command3.into}": one is the other or holds it. Match two separate groups (the second usually hidden).`, { ...where, ids: [id, command3.into] }));
             continue;
           }
           const m = matchMotionNodes(entry.node, into.node);
           if (m.unpairedInto.length)
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "match-unpaired", `${m.unpairedInto.map((x) => `"${x}"`).join(", ")} in "${command3.into}" ${m.unpairedInto.length > 1 ? "have" : "has"} no partner in "${id}", so ${m.unpairedInto.length > 1 ? "they do" : "it does"} not appear; add a part with the same name or id to "${id}" (it can start hidden or tiny).`, { ...where, ids: m.unpairedInto }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "match-unpaired", `${m.unpairedInto.map((x) => `"${x}"`).join(", ")} in "${command3.into}" ${m.unpairedInto.length > 1 ? "have" : "has"} no partner in "${id}", so ${m.unpairedInto.length > 1 ? "they do" : "it does"} not appear; add a part with the same name or id to "${id}" (it can start hidden or tiny).`, { ...where, ids: m.unpairedInto }));
         }
       }
       const style = command3.type === "enter" || command3.type === "exit" ? command3.style : void 0;
       if (style === "wipe" || style === "iris" || style === "split") {
         for (const id of targets)
           if (!motionRevealPadding(nodes.get(id)))
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "reveal-no-box", `"${id}" has no width or height (a straight line), so a ${style} cannot clip it and it fades instead; use style "${command3.type === "enter" ? "draw" : "undraw"}" for a line.`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "reveal-no-box", `"${id}" has no width or height (a straight line), so a ${style} cannot clip it and it fades instead; use style "${command3.type === "enter" ? "draw" : "undraw"}" for a line.`, { ...where, ids: [id] }));
       }
       if (command3.type === "style") {
         for (const key of ["fill", "stroke"]) {
           const color = command3[key];
           if (color === void 0) continue;
           if (_chunkA6QWKBJPcjs.normalizeTokenColor.call(void 0, color) === null) {
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "invalid-color", `${key} "${color}" is not a colour this editor reads; use hex ("#0ea5e9"), rgb() or rgba().`, where));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "invalid-color", `${key} "${color}" is not a colour this editor reads; use hex ("#0ea5e9"), rgb() or rgba().`, where));
             continue;
           }
           for (const id of targets) {
             const node = nodes.get(id).node;
             const paths = node.type === "path" ? [node] : _chunkBQE3Y6ZOcjs.collectPathNodes.call(void 0, node);
             if (paths.some((p) => p[key] !== void 0 && p[key] !== null && typeof p[key] !== "string"))
-              issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient ${key}; it switches to ${color} at the end instead of blending.`, { ...where, ids: [id] }));
+              issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient ${key}; it switches to ${color} at the end instead of blending.`, { ...where, ids: [id] }));
           }
         }
       }
       if (command3.type === "color-pulse") {
         const key = _nullishCoalesce(command3.paint, () => ( "fill"));
         const color = _nullishCoalesce(command3.color, () => ( "#f59e0b"));
-        if (_chunkA6QWKBJPcjs.normalizeTokenColor.call(void 0, color) === null) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "invalid-color", `color "${color}" is not a colour this editor reads; use hex ("#0ea5e9"), rgb() or rgba().`, where));
+        if (_chunkA6QWKBJPcjs.normalizeTokenColor.call(void 0, color) === null) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "invalid-color", `color "${color}" is not a colour this editor reads; use hex ("#0ea5e9"), rgb() or rgba().`, where));
         else
           for (const id of targets) {
             const node = nodes.get(id).node;
             const paths = node.type === "path" ? [node] : _chunkBQE3Y6ZOcjs.collectPathNodes.call(void 0, node);
             if (paths.some((p) => typeof p[key] !== "string"))
-              issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient or no ${key}, so a colour pulse cannot tint it; give it a solid ${key} or pulse the ${key === "fill" ? "stroke" : "fill"}.`, { ...where, ids: [id] }));
+              issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "paint-not-color", `"${id}" has a gradient or no ${key}, so a colour pulse cannot tint it; give it a solid ${key} or pulse the ${key === "fill" ? "stroke" : "fill"}.`, { ...where, ids: [id] }));
           }
       }
       if (command3.type === "effect") {
@@ -2075,9 +2479,9 @@ function checkMotionScene(scene) {
           const params = NUMERIC_PARAMS(node, command3.effect);
           const effects = (_nullishCoalesce(node.effects, () => ( []))).map((e) => e.id);
           if (!params)
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-effect", `"${id}" has no effect ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, command3.effect, effects)}${effects.length ? `; its effects are ${effects.map((e) => `"${e}"`).join(", ")}` : "; it has no live effects"}.`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-effect", `"${id}" has no effect ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, command3.effect, effects)}${effects.length ? `; its effects are ${effects.map((e) => `"${e}"`).join(", ")}` : "; it has no live effects"}.`, { ...where, ids: [id] }));
           else if (!params.includes(command3.param))
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-effect-param", `Effect "${command3.effect}" has no numeric parameter ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, command3.param, params)}; use one of ${params.join(", ")}.`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-effect-param", `Effect "${command3.effect}" has no numeric parameter ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, command3.param, params)}; use one of ${params.join(", ")}.`, { ...where, ids: [id] }));
         }
       }
       if (timing) {
@@ -2086,10 +2490,10 @@ function checkMotionScene(scene) {
           const before = Math.max(0, timing.start - 0.5);
           const visible = timing.start > 0 ? visibleAt(timeline, id, before, node) : node.visible !== false;
           if (command3.type === "enter" && visible && timing.start > 0)
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "enter-visible", `"${id}" is already showing when it enters, so it blinks out first; remove the enter or exit it earlier.`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "enter-visible", `"${id}" is already showing when it enters, so it blinks out first; remove the enter or exit it earlier.`, { ...where, ids: [id] }));
           const probe = command3.type === "exit" ? timing.start + 0.5 : (timing.start + timing.end) / 2;
           if (command3.type !== "enter" && command3.type !== "draw" && !visibleAt(timeline, id, probe, node))
-            issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "exit-hidden", `"${id}" is hidden when this ${command3.type} starts, so it is not seen; enter it first.`, { ...where, ids: [id] }));
+            issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "exit-hidden", `"${id}" is hidden when this ${command3.type} starts, so it is not seen; enter it first.`, { ...where, ids: [id] }));
         }
       }
     });
@@ -2097,10 +2501,10 @@ function checkMotionScene(scene) {
   const drivers = _nullishCoalesce(scene.drivers, () => ( []));
   drivers.forEach((d, i) => {
     for (const id of [d.target, d.source.node])
-      if (!nodes.has(id)) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-target", `Driver ${i + 1} names ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, [...nodes.keys()])}, which the artwork does not have.`, { ids: [id] }));
+      if (!nodes.has(id)) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-target", `Driver ${i + 1} names ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, [...nodes.keys()])}, which the artwork does not have.`, { ids: [id] }));
   });
   {
-    const key = (n, p) => `${n}.${p}`;
+    const key = (n2, p) => `${n2}.${p}`;
     const edges = /* @__PURE__ */ new Map();
     for (const d of drivers) edges.set(key(d.target, d.property), [..._nullishCoalesce(edges.get(key(d.target, d.property)), () => ( [])), key(d.source.node, d.source.property)]);
     const state = /* @__PURE__ */ new Map();
@@ -2109,25 +2513,25 @@ function checkMotionScene(scene) {
       if (state.get(k) === 2) return false;
       if (state.get(k) === 1) return loop.push(...trail.slice(trail.indexOf(k)), k), true;
       state.set(k, 1);
-      for (const n of _nullishCoalesce(edges.get(k), () => ( []))) if (visit(n, [...trail, k])) return true;
+      for (const n2 of _nullishCoalesce(edges.get(k), () => ( []))) if (visit(n2, [...trail, k])) return true;
       state.set(k, 2);
       return false;
     };
     for (const k of edges.keys()) if (visit(k, [])) break;
-    if (loop.length) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "driver-cycle", `Drivers follow each other round in a loop (${loop.join(" \u2190 ")}); remove one of them.`, { ids: [...new Set(loop.map((k) => k.split(".")[0]))] }));
+    if (loop.length) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "driver-cycle", `Drivers follow each other round in a loop (${loop.join(" \u2190 ")}); remove one of them.`, { ids: [...new Set(loop.map((k) => k.split(".")[0]))] }));
   }
   for (const [name, clip] of Object.entries(_nullishCoalesce(scene.clips, () => ( {}))))
     for (const command3 of clip.run)
       if (command3.type !== "wait") {
         for (const id of command3.targets)
-          if (id !== MOTION_CLIP_TARGET && !nodes.has(id)) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-target", `Clip "${name}" names ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, [...nodes.keys()])}, which the artwork does not have; use "$" for the node the clip is played on.`, { ids: [id] }));
+          if (id !== MOTION_CLIP_TARGET && !nodes.has(id)) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-target", `Clip "${name}" names ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, [...nodes.keys()])}, which the artwork does not have; use "$" for the node the clip is played on.`, { ids: [id] }));
       }
   if (scene.trigger) {
-    if ((_nullishCoalesce(scene.loop, () => ( "none"))) !== "none") issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "trigger-loop", `The scene plays on ${scene.trigger}, so its "${scene.loop}" loop does not apply; set loop to "none" or remove the trigger.`, {}));
+    if ((_nullishCoalesce(scene.loop, () => ( "none"))) !== "none") issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "trigger-loop", `The scene plays on ${scene.trigger}, so its "${scene.loop}" loop does not apply; set loop to "none" or remove the trigger.`, {}));
     if (scene.trigger === "click") {
-      if (scene.shots.length === 1) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "click-one-shot", "The scene plays on click but has one shot, so every click replays it from the start; split it into shots (each click plays the next one).", { shot: scene.shots[0].id }));
+      if (scene.shots.length === 1) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "click-one-shot", "The scene plays on click but has one shot, so every click replays it from the start; split it into shots (each click plays the next one).", { shot: scene.shots[0].id }));
       scene.shots.forEach((shot, i) => {
-        if (i > 0 && shot.at) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "click-cue", `Shot "${shot.id}" is cued, but on click a shot starts when it is clicked to; remove its "at" or the trigger.`, { shot: shot.id }));
+        if (i > 0 && shot.at) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "click-cue", `Shot "${shot.id}" is cued, but on click a shot starts when it is clicked to; remove its "at" or the trigger.`, { shot: shot.id }));
       });
     }
   }
@@ -2135,11 +2539,11 @@ 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', _107 => _107.narration, 'optionalAccess', _108 => _108.words, 'access', _109 => _109.length]), () => ( 0))} words (indexes from 0)`;
-      issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-cue", `Shot "${shot.id}" is cued to ${what}.`, { shot: shot.id }));
+      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', _128 => _128.narration, 'optionalAccess', _129 => _129.words, 'access', _130 => _130.length]), () => ( 0))} words (indexes from 0)`;
+      issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-cue", `Shot "${shot.id}" is cued to ${what}.`, { shot: shot.id }));
     } else if (timing.missedBy !== void 0) {
       const late = Math.round(timing.missedBy);
-      issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "cue-missed", `Shot "${shot.id}" is cued at ${Math.round(timing.cue)} ms but starts ${late} ms late, because the shot before runs until ${Math.round(timing.start)} ms; shorten that shot (its hold, durations or speed) or cue this one later.`, { shot: shot.id, measured: late, needed: 0, unit: "ms" }));
+      issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "cue-missed", `Shot "${shot.id}" is cued at ${Math.round(timing.cue)} ms but starts ${late} ms late, because the shot before runs until ${Math.round(timing.start)} ms; shorten that shot (its hold, durations or speed) or cue this one later.`, { shot: shot.id, measured: late, needed: 0, unit: "ms" }));
     }
   });
   for (const [key, track] of timeline.tracks) {
@@ -2151,7 +2555,7 @@ function checkMotionScene(scene) {
         const property = key.split("\0")[1];
         if (!a.node) continue;
         issues.push(
-          _chunkERJA5CGTcjs.motionIssue.call(void 0, "overlap", `"${a.node}" ${property} is changed by two commands at once (shot "${a.shot}" command ${a.command + 1} and shot "${b.shot}" command ${b.command + 1}); the later one takes over. Start it after the first ends, or use with: "after".`, {
+          _chunkDGWOGQJ5cjs.motionIssue.call(void 0, "overlap", `"${a.node}" ${property} is changed by two commands at once (shot "${a.shot}" command ${a.command + 1} and shot "${b.shot}" command ${b.command + 1}); the later one takes over. Start it after the first ends, or use with: "after".`, {
             shot: b.shot,
             command: b.command,
             ids: [a.node]
@@ -2168,26 +2572,26 @@ function checkMotionScene(scene) {
     const cam = frame.camera;
     const docIndex = indexMotionNodes(frame.document.nodes);
     for (const id of command3.targets) {
-      const b = _optionalChain([docIndex, 'access', _110 => _110.get, 'call', _111 => _111(id), 'optionalAccess', _112 => _112.bounds]);
+      const b = _optionalChain([docIndex, 'access', _131 => _131.get, 'call', _132 => _132(id), 'optionalAccess', _133 => _133.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) {
         reported.add(id);
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "out-of-frame", `"${id}" is outside the camera when this ${command3.type} ends, so it is not seen; move it into frame or move the camera.`, { shot: timing.shot, command: timing.command, ids: [id] }));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "out-of-frame", `"${id}" is outside the camera when this ${command3.type} ends, so it is not seen; move it into frame or move the camera.`, { shot: timing.shot, command: timing.command, ids: [id] }));
       }
     }
   }
   if (scene.controls) {
     for (const control of scene.controls) {
       if (!usesColor(scene, control.default))
-        issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "unknown-control-color", `Control "${control.name}" stands for ${control.default}, which the scene never uses; set its default to a colour in the artwork.`));
+        issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "unknown-control-color", `Control "${control.name}" stands for ${control.default}, which the scene never uses; set its default to a colour in the artwork.`));
     }
   }
   if (scene.target && scene.shots.length) {
     const seconds = Math.round(timeline.duration / 100) / 10;
     const [min, max] = scene.target;
-    if (seconds > max) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "scene-too-long", `The scene runs ${seconds} s, past its ${max} s target; shorten holds or durations, or fit it (fit_animation).`, { measured: seconds, needed: max, unit: "s" }));
-    if (seconds < min) issues.push(_chunkERJA5CGTcjs.motionIssue.call(void 0, "scene-too-short", `The scene runs ${seconds} s, under its ${min} s target; hold longer, add shots, or fit it (fit_animation).`, { measured: seconds, needed: min, unit: "s" }));
+    if (seconds > max) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "scene-too-long", `The scene runs ${seconds} s, past its ${max} s target; shorten holds or durations, or fit it (fit_animation).`, { measured: seconds, needed: max, unit: "s" }));
+    if (seconds < min) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "scene-too-short", `The scene runs ${seconds} s, under its ${min} s target; hold longer, add shots, or fit it (fit_animation).`, { measured: seconds, needed: min, unit: "s" }));
   }
   return issues;
 }
@@ -2216,7 +2620,7 @@ var fail = (message) => {
 };
 function shotIndex(scene, id) {
   const i = scene.shots.findIndex((s) => s.id === id);
-  if (i < 0) fail(`There is no shot ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, scene.shots.map((s) => s.id))}; the shots are ${scene.shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
+  if (i < 0) fail(`There is no shot ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, scene.shots.map((s) => s.id))}; the shots are ${scene.shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
   return i;
 }
 function position(at, length, what) {
@@ -2228,9 +2632,9 @@ var replaceShot = (scene, index, shot) => ({ ...scene, shots: scene.shots.map((s
 function freshShotId(scene, base = "shot") {
   const used = new Set(scene.shots.map((s) => s.id));
   if (!used.has(base)) return base;
-  let n = 2;
-  while (used.has(`${base}-${n}`)) n++;
-  return `${base}-${n}`;
+  let n2 = 2;
+  while (used.has(`${base}-${n2}`)) n2++;
+  return `${base}-${n2}`;
 }
 function applyOne(scene, edit) {
   switch (edit.op) {
@@ -2274,7 +2678,7 @@ function applyOne(scene, edit) {
       if (typeof edit.name !== "string" || !edit.name) fail('Give the clip a "name".');
       const clips = { ..._nullishCoalesce(scene.clips, () => ( {})) };
       if (edit.clip === null) {
-        if (!clips[edit.name]) fail(`There is no clip ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, edit.name, Object.keys(clips))} to delete.`);
+        if (!clips[edit.name]) fail(`There is no clip ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, edit.name, Object.keys(clips))} to delete.`);
         const playing = scene.shots.filter((s) => s.run.some((c) => c.type === "play" && c.clip === edit.name)).map((s) => `"${s.id}"`);
         if (playing.length) fail(`Clip "${edit.name}" is played in shot${playing.length > 1 ? "s" : ""} ${playing.join(", ")}; remove those play commands first.`);
         delete clips[edit.name];
@@ -2380,7 +2784,7 @@ function applyOne(scene, edit) {
       const names = new Set(edit.controls.map((c) => c.name));
       for (const preset2 of _nullishCoalesce(next.presets, () => ( [])))
         for (const key of Object.keys(preset2.values))
-          if (!names.has(key)) fail(`Preset "${preset2.name}" sets ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, key, names)}, which is not a control.`);
+          if (!names.has(key)) fail(`Preset "${preset2.name}" sets ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, key, names)}, which is not a control.`);
       return next;
     }
     case "replace_scene":
@@ -2388,11 +2792,11 @@ function applyOne(scene, edit) {
   }
 }
 function errorKeys(issues) {
-  return new Set(issues.filter((i) => i.severity === "error").map(_chunkERJA5CGTcjs.motionIssueKey));
+  return new Set(issues.filter((i) => i.severity === "error").map(_chunkDGWOGQJ5cjs.motionIssueKey));
 }
 function editHints(before, after) {
-  const old = new Set(before.map(_chunkERJA5CGTcjs.motionIssueKey));
-  return after.filter((i) => i.code === "overlap" && !old.has(_chunkERJA5CGTcjs.motionIssueKey.call(void 0, i))).map(_chunkERJA5CGTcjs.motionIssueLine);
+  const old = new Set(before.map(_chunkDGWOGQJ5cjs.motionIssueKey));
+  return after.filter((i) => i.code === "overlap" && !old.has(_chunkDGWOGQJ5cjs.motionIssueKey.call(void 0, i))).map(_chunkDGWOGQJ5cjs.motionIssueLine);
 }
 function applyMotionEdits(scene, edits) {
   const list = Array.isArray(edits) ? edits : [edits];
@@ -2400,9 +2804,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', _113 => _113.op])}): ` : "";
+    const prefix = list.length > 1 ? `op ${i + 1} (${_optionalChain([edit, 'optionalAccess', _134 => _134.op])}): ` : "";
     if (!edit || !MOTION_EDIT_OPS.includes(edit.op))
-      return { ok: false, error: `${prefix}Unknown op ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, String(_optionalChain([edit, 'optionalAccess', _114 => _114.op])), MOTION_EDIT_OPS)}. Nothing was changed.` };
+      return { ok: false, error: `${prefix}Unknown op ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, String(_optionalChain([edit, 'optionalAccess', _135 => _135.op])), MOTION_EDIT_OPS)}. Nothing was changed.` };
     try {
       next = applyOne(next, edit);
     } catch (error) {
@@ -2414,8 +2818,8 @@ function applyMotionEdits(scene, edits) {
   }
   const issues = checkMotionScene(next);
   const had = errorKeys(before);
-  const added = issues.filter((i) => i.severity === "error" && !had.has(_chunkERJA5CGTcjs.motionIssueKey.call(void 0, i)));
-  if (added.length) return { ok: false, error: `Nothing was changed: ${added.map(_chunkERJA5CGTcjs.motionIssueLine).join(" ")}` };
+  const added = issues.filter((i) => i.severity === "error" && !had.has(_chunkDGWOGQJ5cjs.motionIssueKey.call(void 0, i)));
+  if (added.length) return { ok: false, error: `Nothing was changed: ${added.map(_chunkDGWOGQJ5cjs.motionIssueLine).join(" ")}` };
   return { ok: true, scene: next, issues, hints: editHints(before, issues) };
 }
 var REF = /^\$(\d+|last)((?:\.[A-Za-z_]\w*|\[\d+\])+)$/;
@@ -2424,21 +2828,21 @@ function resolveMotionEditRefs(scene, edits) {
   const resolved = [];
   let next = scene;
   for (let i = 0; i < edits.length; i++) {
-    const where = `op ${i + 1} (${_optionalChain([edits, 'access', _115 => _115[i], 'optionalAccess', _116 => _116.op])})`;
+    const where = `op ${i + 1} (${_optionalChain([edits, 'access', _136 => _136[i], 'optionalAccess', _137 => _137.op])})`;
     let problem = null;
     const walk = (v) => {
       if (typeof v === "string") {
         if (v.startsWith("$$")) return v.slice(1);
         const m = REF.exec(v);
         if (!m) return v;
-        const n = m[1] === "last" ? i - 1 : Number(m[1]);
-        if (!(n >= 0 && n < i)) {
-          problem = `${where}: "${v}" refers to op ${n + 1}, but only ops before this one (1 to ${i}) can be referred to.`;
+        const n2 = m[1] === "last" ? i - 1 : Number(m[1]);
+        if (!(n2 >= 0 && n2 < i)) {
+          problem = `${where}: "${v}" refers to op ${n2 + 1}, but only ops before this one (1 to ${i}) can be referred to.`;
           return v;
         }
-        let value = outcomes[n];
+        let value = outcomes[n2];
         for (const part of _nullishCoalesce(m[2].match(/\.[A-Za-z_]\w*|\[\d+\]/g), () => ( []))) value = value == null ? void 0 : value[part.startsWith(".") ? part.slice(1) : part.slice(1, -1)];
-        if (value === void 0) problem = `${where}: "${v}" has no value; op ${n + 1} made ${JSON.stringify(outcomes[n])}.`;
+        if (value === void 0) problem = `${where}: "${v}" has no value; op ${n2 + 1} made ${JSON.stringify(outcomes[n2])}.`;
         return value;
       }
       if (Array.isArray(v)) return v.map(walk);
@@ -2457,9 +2861,9 @@ function resolveMotionEditRefs(scene, edits) {
     resolved.push(edit);
     const out = { op: edit.op };
     if (edit.op === "insert_shots") out.shots = edit.shots.map((s) => s.id);
-    if ("shot" in edit && typeof edit.shot === "string") out.shot = edit.op === "update_shot" && _optionalChain([edit, 'access', _117 => _117.set, 'optionalAccess', _118 => _118.id]) ? edit.set.id : edit.shot;
+    if ("shot" in edit && typeof edit.shot === "string") out.shot = edit.op === "update_shot" && _optionalChain([edit, 'access', _138 => _138.set, 'optionalAccess', _139 => _139.id]) ? edit.set.id : edit.shot;
     if (edit.op === "add_commands") {
-      const at = _nullishCoalesce(_nullishCoalesce(edit.at, () => ( _optionalChain([before, 'access', _119 => _119.shots, 'access', _120 => _120.find, 'call', _121 => _121((s) => s.id === edit.shot), 'optionalAccess', _122 => _122.run, 'access', _123 => _123.length]))), () => ( 0));
+      const at = _nullishCoalesce(_nullishCoalesce(edit.at, () => ( _optionalChain([before, 'access', _140 => _140.shots, 'access', _141 => _141.find, 'call', _142 => _142((s) => s.id === edit.shot), 'optionalAccess', _143 => _143.run, 'access', _144 => _144.length]))), () => ( 0));
       out.indexes = edit.commands.map((_, k) => at + k);
     }
     if (edit.op === "move_command") out.indexes = [edit.to];
@@ -2478,7 +2882,7 @@ function fitMotionScene(scene, ms2, options = {}) {
   if (!(Number.isFinite(ms2) && ms2 > 0)) throw new Error("Give the length to fit as a number of milliseconds above 0.");
   const ids = scene.shots.map((s) => s.id);
   const keep = new Set(_nullishCoalesce(options.keep, () => ( [])));
-  for (const id of keep) if (!ids.includes(id)) throw new Error(`There is no shot ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, ids)} to keep.`);
+  for (const id of keep) if (!ids.includes(id)) throw new Error(`There is no shot ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, ids)} to keep.`);
   const timeline = compileMotionScene(scene);
   let kept = 0;
   let rest = 0;
@@ -2506,7 +2910,7 @@ var COLOR_GAP = 80;
 var MAX_VIA = 64;
 function motionNodePose(scene, id, time) {
   const entry = indexMotionNodes(scene.artwork.nodes).get(id);
-  if (!entry) throw new Error(`There is no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, [...indexMotionNodes(scene.artwork.nodes).keys()])} in the artwork.`);
+  if (!entry) throw new Error(`There is no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, [...indexMotionNodes(scene.artwork.nodes).keys()])} in the artwork.`);
   const timeline = compileMotionScene(scene);
   const drawn = indexMotionNodes(motionFrameAt(scene, time).document.nodes).get(id);
   const centre = _chunkBQE3Y6ZOcjs.applyMatrix.call(void 0, entry.parentWorld, { x: entry.center.x + motionPropertyValue(timeline, id, "x", time), y: entry.center.y + motionPropertyValue(timeline, id, "y", time) });
@@ -2524,15 +2928,15 @@ function motionNodePose(scene, id, time) {
     ...typeof fill === "string" && fill !== "transparent" ? { fill } : {},
     ...typeof stroke === "string" && stroke !== "transparent" ? { stroke } : {},
     ...typeof width === "number" ? { strokeWidth: width } : {},
-    bounds: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _124 => _124.bounds]), () => ( null))
+    bounds: _nullishCoalesce(_optionalChain([drawn, 'optionalAccess', _145 => _145.bounds]), () => ( null))
   };
 }
 function simplifyTimedSamples(times, values, tol) {
-  const n = times.length;
-  if (n <= 2) return [...Array(n).keys()];
-  const keep = new Uint8Array(n);
-  keep[0] = keep[n - 1] = 1;
-  const stack = [[0, n - 1]];
+  const n2 = times.length;
+  if (n2 <= 2) return [...Array(n2).keys()];
+  const keep = new Uint8Array(n2);
+  keep[0] = keep[n2 - 1] = 1;
+  const stack = [[0, n2 - 1]];
   while (stack.length) {
     const [a, b] = stack.pop();
     let worst = -1;
@@ -2559,8 +2963,8 @@ function simplifyTimedSamples(times, values, tol) {
   keep.forEach((k, i) => k && out.push(i));
   return out;
 }
-var round2 = (n, places = 2) => Math.round(n * 10 ** places) / 10 ** places || 0;
-var ms = (n) => Math.max(0, Math.round(n));
+var round2 = (n2, places = 2) => Math.round(n2 * 10 ** places) / 10 ** places || 0;
+var ms = (n2) => Math.max(0, Math.round(n2));
 function motionTakeProblems(scene, take) {
   const problems = [];
   const nodes = indexMotionNodes(scene.artwork.nodes);
@@ -2569,7 +2973,7 @@ function motionTakeProblems(scene, take) {
   take.samples.forEach((s, i) => {
     const where = `Sample ${i + 1}`;
     if (!s || typeof s !== "object") return problems.push(`${where} must be an object.`);
-    if (typeof s.node !== "string" || !nodes.has(s.node)) problems.push(`${where}: the artwork has no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, String(s.node), [...nodes.keys()])}; get_animation lists the element ids.`);
+    if (typeof s.node !== "string" || !nodes.has(s.node)) problems.push(`${where}: the artwork has no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, String(s.node), [...nodes.keys()])}; get_animation lists the element ids.`);
     if (!num2(s.t) || s.t < 0) problems.push(`${where}: "t" must be ms from the start of the take, \u2265 0.`);
     if (s.x === void 0 !== (s.y === void 0)) problems.push(`${where}: give "x" and "y" together (the centre, document units).`);
     for (const k of ["x", "y", "scaleX", "scaleY", "rotation", "opacity", "strokeWidth"]) if (s[k] !== void 0 && !num2(s[k])) problems.push(`${where}: "${k}" must be a number.`);
@@ -2648,7 +3052,7 @@ function channelCommands(node, channel, pose, samples, tol, kept) {
     const via = [];
     for (const k of keep.slice(1, -1)) {
       const f = round2((list[k].t - first.t) / span, 6);
-      if (f > (_nullishCoalesce(_optionalChain([via, 'access', _125 => _125.at, 'call', _126 => _126(-1), 'optionalAccess', _127 => _127.f]), () => ( 0))) && f < 1) via.push({ s: list[k], f });
+      if (f > (_nullishCoalesce(_optionalChain([via, 'access', _146 => _146.at, 'call', _147 => _147(-1), 'optionalAccess', _148 => _148.f]), () => ( 0))) && f < 1) via.push({ s: list[k], f });
     }
     const extra = via.length ? { via: via.map(({ s }) => ({ x: round2(s.v[0]), y: round2(s.v[1]) })), times: via.map(({ f }) => f) } : {};
     out.push({ start: first.t, command: make(end.v, span, "linear", extra) });
@@ -2701,10 +3105,10 @@ function motionTakeShot(scene, take, options = {}) {
   if (!run.length) Object.assign(shot, { run: [{ type: "wait", duration: ms(Math.max(1, length)) }], hold: 0 });
   return { shot, at, start, samples: { given: take.samples.length, kept: kept.n } };
 }
-function motionClientToDocument(camera, box, clientX, clientY) {
-  const k = Math.min(box.width / camera.width, box.height / camera.height) || 1;
-  const ox = box.left + (box.width - camera.width * k) / 2;
-  const oy = box.top + (box.height - camera.height * k) / 2;
+function motionClientToDocument(camera, box2, clientX, clientY) {
+  const k = Math.min(box2.width / camera.width, box2.height / camera.height) || 1;
+  const ox = box2.left + (box2.width - camera.width * k) / 2;
+  const oy = box2.top + (box2.height - camera.height * k) / 2;
   return { x: camera.x + (clientX - ox) / k, y: camera.y + (clientY - oy) / k };
 }
 
@@ -2716,8 +3120,8 @@ var FLAIR_EASES = {
 };
 var FLAIR_EXPORT_VERSION = "0.39";
 function flairAtLeast(version, min) {
-  const a = version.split(".").map((n) => parseInt(n, 10) || 0);
-  const b = min.split(".").map((n) => parseInt(n, 10) || 0);
+  const a = version.split(".").map((n2) => parseInt(n2, 10) || 0);
+  const b = min.split(".").map((n2) => parseInt(n2, 10) || 0);
   for (let i = 0; i < Math.max(a.length, b.length); i++) if ((_nullishCoalesce(a[i], () => ( 0))) !== (_nullishCoalesce(b[i], () => ( 0)))) return (_nullishCoalesce(a[i], () => ( 0))) > (_nullishCoalesce(b[i], () => ( 0)));
   return true;
 }
@@ -2767,8 +3171,8 @@ function toFlairSvgMotion(scene, options = {}) {
     return back && curves ? flairCurveFor(back, curves) : void 0;
   };
   const plays = (s) => (!s.behavior || behaviors) && (!s.steps || strobes) && !s.geometric;
-  const round4 = (n) => Math.round(n * 10 ** precision) / 10 ** precision;
-  const f = (n) => String(round4(n));
+  const round4 = (n2) => Math.round(n2 * 10 ** precision) / 10 ** precision;
+  const f = (n2) => String(round4(n2));
   const timeline = compileMotionScene(scene);
   const nodes = indexMotionNodes(scene.artwork.nodes);
   const notes = [];
@@ -2793,14 +3197,14 @@ function toFlairSvgMotion(scene, options = {}) {
   const usedIds = new Set(nodes.keys());
   const freshId = (base) => {
     let id = base;
-    for (let n = 2; usedIds.has(id); n++) id = `${base}-${n}`;
+    for (let n2 = 2; usedIds.has(id); n2++) id = `${base}-${n2}`;
     usedIds.add(id);
     return id;
   };
   for (const id of animatedNodes) {
     const entry = nodes.get(id);
     const node = entry.node;
-    const drawn = [...entry.ancestors.map((a) => nodes.get(a).node), node].every((n) => n.visible !== false);
+    const drawn = [...entry.ancestors.map((a) => nodes.get(a).node), node].every((n2) => n2.visible !== false);
     for (const [p, name] of [["clipRect", "reveal"], ["clipCircle", "iris"]]) {
       if (!drawn || !timeline.tracks.has(motionTrackKey(id, p))) continue;
       const wrapper = freshId(`${id}--${name}`);
@@ -2826,7 +3230,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', _128 => _128(entry, timeline, 0, nodes), 'optionalAccess', _129 => _129.follow]);
+        const at = _optionalChain([motionNodeOffset, 'call', _149 => _149(entry, timeline, 0, nodes), 'optionalAccess', _150 => _150.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)) });
@@ -2887,7 +3291,7 @@ function toFlairSvgMotion(scene, options = {}) {
           exact: () => false,
           value: (t) => {
             const frame = motionFrameAt(scene, t, { draw: false, offsets: false });
-            const now = _chunkBQE3Y6ZOcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _130 => _130(frame.document.nodes), 'access', _131 => _131.get, 'call', _132 => _132(id), 'optionalAccess', _133 => _133.node]));
+            const now = _chunkBQE3Y6ZOcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _151 => _151(frame.document.nodes), 'access', _152 => _152.get, 'call', _153 => _153(id), 'optionalAccess', _154 => _154.node]));
             if (!now || now.type !== "path") return "";
             const bezier = _chunkGF2RBSDMcjs.transformBezierPath.call(void 0, _chunkBQE3Y6ZOcjs.vectorPathWorldBezier.call(void 0, now, _chunkBQE3Y6ZOcjs.IDENTITY_MATRIX, { effects: false }), inverse);
             return _chunkGF2RBSDMcjs.bezierPathToSvg.call(void 0, bezier, { precision: Math.min(precision, 2) });
@@ -2901,8 +3305,8 @@ function toFlairSvgMotion(scene, options = {}) {
   const moveSegments = windows.map((w) => ({ node: "", property: "camera", start: w.start, end: w.end, from: [], to: [], ease: "linear", shot: w.shot, command: -1 }));
   const sampledMove = new WeakSet(moveSegments);
   const cameraValue = windows.length ? (t) => {
-    const box = motionFrameAt(scene, t, { draw: false, offsets: false, effects: options.effects }).camera;
-    return [box.x, box.y, box.width, box.height].map(round4);
+    const box2 = motionFrameAt(scene, t, { draw: false, offsets: false, effects: options.effects }).camera;
+    return [box2.x, box2.y, box2.width, box2.height].map(round4);
   } : (t) => trackValue(camera, t).map(round4);
   if (camera.length || windows.length) channels.push({ id: "", kind: "view", segments: [...camera, ...moveSegments].sort((a, b) => a.start - b.start), exact: (seg) => !sampledMove.has(seg), overshoot: true, value: cameraValue });
   const cameraTag = (t) => {
@@ -2910,7 +3314,7 @@ function toFlairSvgMotion(scene, options = {}) {
     if (w) return `${w.move}@${w.shot}`;
     const seg = camera.find((x) => t >= x.start - 1e-6 && t < Math.max(x.end, x.start + 1e-3));
     const shot = seg ? scene.shots.find((x) => x.id === seg.shot) : void 0;
-    const move = _optionalChain([_chunk2K5TELHVcjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'optionalAccess', _134 => _134.camera, 'optionalAccess', _135 => _135.in])), 'optionalAccess', _136 => _136.move]);
+    const move = _optionalChain([_chunkJAOSL334cjs.cameraMoveParts.call(void 0, _optionalChain([shot, 'optionalAccess', _155 => _155.camera, 'optionalAccess', _156 => _156.in])), 'optionalAccess', _157 => _157.move]);
     return move && shot ? `${move}@${shot.id}` : void 0;
   };
   const unplayed = scene.shots.filter((x) => x.camera && (x.camera.in !== void 0 || x.camera.during !== void 0) && !windows.some((w) => w.shot === x.id));
@@ -2927,8 +3331,8 @@ function toFlairSvgMotion(scene, options = {}) {
       ...delay > 0 ? { delay: round4(delay) } : {},
       ms: round4(ms2),
       ease: written,
-      ..._optionalChain([segment, 'optionalAccess', _137 => _137.behavior]) ? { behavior: segment.behavior } : {},
-      ..._optionalChain([segment, 'optionalAccess', _138 => _138.steps]) ? { strobe: segment.steps } : {}
+      ..._optionalChain([segment, 'optionalAccess', _158 => _158.behavior]) ? { behavior: segment.behavior } : {},
+      ..._optionalChain([segment, 'optionalAccess', _159 => _159.steps]) ? { strobe: segment.steps } : {}
     };
     if (channel.kind === "view") {
       const tag2 = cameraTag(delay);
@@ -2965,11 +3369,11 @@ function toFlairSvgMotion(scene, options = {}) {
         if (!same(from, to) || channel.kind === "view") emit(channel, a, b - a, from, to, ease, first);
         continue;
       }
-      const n = Math.max(1, Math.ceil((b - a) * fps / 1e3));
+      const n2 = Math.max(1, Math.ceil((b - a) * fps / 1e3));
       let prev = channel.value(a);
-      for (let k = 1; k <= n; k++) {
-        const t0 = a + (b - a) * (k - 1) / n;
-        const t1 = a + (b - a) * k / n;
+      for (let k = 1; k <= n2; k++) {
+        const t0 = a + (b - a) * (k - 1) / n2;
+        const t1 = a + (b - a) * k / n2;
         const next = channel.value(t1);
         const jump = channel.kind === "view" && active.some((x) => sampledMove.has(x)) ? viewJump(channel.value, t0, t1) : void 0;
         if (jump) {
@@ -3001,10 +3405,10 @@ function toFlairSvgMotion(scene, options = {}) {
         continue;
       }
       const until = Math.min(seg.end, ...starts.filter((t) => t > seg.start));
-      const n = Math.max(1, Math.ceil((until - seg.start) * fps / 1e3));
-      for (let k = 1; k <= n; k++) {
-        const t0 = seg.start + (until - seg.start) * (k - 1) / n;
-        const t1 = seg.start + (until - seg.start) * k / n;
+      const n2 = Math.max(1, Math.ceil((until - seg.start) * fps / 1e3));
+      for (let k = 1; k <= n2; k++) {
+        const t0 = seg.start + (until - seg.start) * (k - 1) / n2;
+        const t1 = seg.start + (until - seg.start) * k / n2;
         animate.push({ ...along, ...t0 > 0 ? { delay: round4(t0) } : {}, ms: round4(t1 - t0), ease: "linear", at: [progress(t0), progress(t1)] });
         sampled++;
       }
@@ -3032,7 +3436,7 @@ function toFlairSvgMotion(scene, options = {}) {
   let svg = _chunkBQE3Y6ZOcjs.vectorDocumentToSvg.call(void 0, { ...scene.artwork, nodes: _chunkBQE3Y6ZOcjs.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', _139 => _139.controls, 'optionalAccess', _140 => _140.length])) {
+  if (_optionalChain([scene, 'access', _160 => _160.controls, 'optionalAccess', _161 => _161.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} -->`);
@@ -3054,7 +3458,7 @@ function toFlairVectorEffect(scene, options = {}) {
     tags: _nullishCoalesce(options.tags, () => ( [])),
     motion: out.motion,
     hold: out.hold,
-    ..._optionalChain([scene, 'access', _141 => _141.presets, 'optionalAccess', _142 => _142.length]) ? { presets: scene.presets } : {},
+    ..._optionalChain([scene, 'access', _162 => _162.presets, 'optionalAccess', _163 => _163.length]) ? { presets: scene.presets } : {},
     ...out.trigger ? { trigger: out.trigger } : {}
   };
 }
@@ -3073,17 +3477,17 @@ function toFlairEffectDocument(scene, options = {}) {
   };
 }
 function viewJump(value, t0, t1) {
-  const box = (t) => value(t);
+  const box2 = (t) => value(t);
   const apart = (a2, b2) => Math.hypot(a2[0] + a2[2] / 2 - b2[0] - b2[2] / 2, a2[1] + a2[3] / 2 - b2[1] - b2[3] / 2, a2[2] - b2[2]);
   let lo = t0;
   let hi = t1;
   for (let i = 0; i < 40 && hi - lo > 1e-4; i++) {
     const mid = (lo + hi) / 2;
-    if (apart(box(lo), box(mid)) >= apart(box(mid), box(hi))) hi = mid;
+    if (apart(box2(lo), box2(mid)) >= apart(box2(mid), box2(hi))) hi = mid;
     else lo = mid;
   }
-  const a = box(lo);
-  const b = box(hi);
+  const a = box2(lo);
+  const b = box2(hi);
   return apart(a, b) > Math.min(a[2], b[2]) / 20 ? hi : void 0;
 }
 
@@ -3112,7 +3516,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', _143 => _143.value]), () => ( ""))).replace(/"/g, '\\"');
+    return (_nullishCoalesce(_optionalChain([d, 'optionalAccess', _164 => _164.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 };
@@ -3138,7 +3542,7 @@ function poseOf(value, entry) {
   return { dx: moved.x - c.x, dy: moved.y - c.y, rotation: Math.atan2(o[1], o[0]) * 180 / Math.PI, sx, sy };
 }
 var near = (a, b, eps = 1e-6) => Math.abs(a - b) < eps;
-var r3 = (n) => Math.round(n * 1e3) / 1e3;
+var r3 = (n2) => Math.round(n2 * 1e3) / 1e3;
 function commandsFor(anim, nodes, entered, notes) {
   const id = anim.id;
   const entry = nodes.get(id);
@@ -3166,7 +3570,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', _144 => _144.at, 'optionalAccess', _145 => _145[0]]), () => ( 0)), to: _nullishCoalesce(_optionalChain([anim, 'access', _146 => _146.at, 'optionalAccess', _147 => _147[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', _165 => _165.at, 'optionalAccess', _166 => _166[0]]), () => ( 0)), to: _nullishCoalesce(_optionalChain([anim, 'access', _167 => _167.at, 'optionalAccess', _168 => _168[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") {
@@ -3177,7 +3581,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', _148 => _148.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', _169 => _169.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) });
@@ -3269,17 +3673,17 @@ ${problems.join("\n")}`);
 }
 function presetColor(value) {
   if (typeof value === "string") return /^#[0-9a-f]{6}$/i.test(value) ? value.toLowerCase() : value;
-  if (Array.isArray(value) && value.length >= 3 && value.slice(0, 3).every((n) => typeof n === "number" && Number.isFinite(n)))
-    return `#${value.slice(0, 3).map((n) => Math.round(Math.min(1, Math.max(0, n)) * 255).toString(16).padStart(2, "0")).join("")}`;
+  if (Array.isArray(value) && value.length >= 3 && value.slice(0, 3).every((n2) => typeof n2 === "number" && Number.isFinite(n2)))
+    return `#${value.slice(0, 3).map((n2) => Math.round(Math.min(1, Math.max(0, n2)) * 255).toString(16).padStart(2, "0")).join("")}`;
   return void 0;
 }
 function fromFlairVectorEffect(effect, options = {}) {
   if (!effect || effect.kind !== "vector" || !effect.motion) throw new Error('Give a Flair vector effect: { kind: "vector", id, name, motion: { svg, animate } }.');
-  const result = fromFlairSvgMotion(effect.motion, { name: _nullishCoalesce(_nullishCoalesce(options.name, () => ( effect.id)), () => ( effect.name)), hold: _nullishCoalesce(options.hold, () => ( effect.hold)), ...effect.trigger === "click" ? { clickSteps: true } : {} });
-  const names = new Set((_nullishCoalesce(result.scene.controls, () => ( []))).map((c) => c.name));
+  const result2 = fromFlairSvgMotion(effect.motion, { name: _nullishCoalesce(_nullishCoalesce(options.name, () => ( effect.id)), () => ( effect.name)), hold: _nullishCoalesce(options.hold, () => ( effect.hold)), ...effect.trigger === "click" ? { clickSteps: true } : {} });
+  const names = new Set((_nullishCoalesce(result2.scene.controls, () => ( []))).map((c) => c.name));
   const presets = (_nullishCoalesce(effect.presets, () => ( []))).map((p) => ({ name: p.name, values: Object.fromEntries(Object.entries(p.values).flatMap(([k, v]) => names.has(k) && presetColor(v) ? [[k, presetColor(v)]] : [])) })).filter((p) => Object.keys(p.values).length);
-  const scene = { ...result.scene, ...effect.description ? { description: effect.description } : {}, ...presets.length ? { presets } : {}, ...effect.trigger ? { trigger: effect.trigger } : {} };
-  const notes = [...result.notes];
+  const scene = { ...result2.scene, ...effect.description ? { description: effect.description } : {}, ...presets.length ? { presets } : {}, ...effect.trigger ? { trigger: effect.trigger } : {} };
+  const notes = [...result2.notes];
   return { scene, notes, issues: checkMotionScene(scene) };
 }
 
@@ -3297,8 +3701,8 @@ var STATIC_TR = () => ({
 function rgba(color) {
   const hex = typeof color === "string" ? _chunkA6QWKBJPcjs.normalizeTokenColor.call(void 0, color) : null;
   if (!hex) return null;
-  const n = (i) => parseInt(hex.slice(i, i + 2), 16) / 255;
-  return [n(1), n(3), n(5), hex.length >= 9 ? parseInt(hex.slice(7, 9), 16) / 255 : 1];
+  const n2 = (i) => parseInt(hex.slice(i, i + 2), 16) / 255;
+  return [n2(1), n2(3), n2(5), hex.length >= 9 ? parseInt(hex.slice(7, 9), 16) / 255 : 1];
 }
 function lottieContours(path, round4) {
   const out = [];
@@ -3329,9 +3733,9 @@ function lottieContours(path, round4) {
       add(cmd.x, cmd.y, cmd.x2, cmd.y2);
     } else if (cmd.type === "Z") {
       cur.c = true;
-      const n = cur.v.length;
-      if (n > 1 && Math.abs(cur.v[n - 1][0] - cur.v[0][0]) < 1e-9 && Math.abs(cur.v[n - 1][1] - cur.v[0][1]) < 1e-9) {
-        cur.i[0] = cur.i[n - 1];
+      const n2 = cur.v.length;
+      if (n2 > 1 && Math.abs(cur.v[n2 - 1][0] - cur.v[0][0]) < 1e-9 && Math.abs(cur.v[n2 - 1][1] - cur.v[0][1]) < 1e-9) {
+        cur.i[0] = cur.i[n2 - 1];
         cur.v.pop();
         cur.i.pop();
         cur.o.pop();
@@ -3353,7 +3757,7 @@ function staticParts(m) {
 function toLottie(scene, options = {}) {
   const fps = _nullishCoalesce(_nullishCoalesce(options.fps, () => ( scene.fps)), () => ( 30));
   const precision = _nullishCoalesce(options.precision, () => ( 3));
-  const round4 = (n) => Math.round(n * 10 ** precision) / 10 ** precision;
+  const round4 = (n2) => Math.round(n2 * 10 ** precision) / 10 ** precision;
   const frame = (ms2) => round4(ms2 * fps / 1e3);
   const timeline = compileMotionScene(scene);
   const nodes = indexMotionNodes(scene.artwork.nodes);
@@ -3386,9 +3790,9 @@ function toLottie(scene, options = {}) {
       else keys.push(k);
     };
     const times = [.../* @__PURE__ */ new Set([0, ...segments.flatMap((s) => [s.start, s.end]), end])].filter((t) => t >= 0 && t <= end).sort((a, b) => a - b);
-    for (let n = 0; n + 1 < times.length; n++) {
-      const a = times[n];
-      const b = times[n + 1];
+    for (let n2 = 0; n2 + 1 < times.length; n2++) {
+      const a = times[n2];
+      const b = times[n2 + 1];
       const active = segments.filter((s) => s.start < b && s.end > a);
       if (!active.length) {
         key(a, value(a), "hold");
@@ -3467,11 +3871,11 @@ 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 _chunkBQE3Y6ZOcjs.vectorPathWorldBezier.call(void 0, path);
-      const now = _optionalChain([indexMotionNodes, 'call', _149 => _149(motionFrameAt(scene, t, { draw: false, offsets: false }).document.nodes), 'access', _150 => _150.get, 'call', _151 => _151(path.id), 'optionalAccess', _152 => _152.node]);
+      const now = _optionalChain([indexMotionNodes, 'call', _170 => _170(motionFrameAt(scene, t, { draw: false, offsets: false }).document.nodes), 'access', _171 => _171.get, 'call', _172 => _172(path.id), 'optionalAccess', _173 => _173.node]);
       return now && now.type === "path" ? _chunkBQE3Y6ZOcjs.vectorPathWorldBezier.call(void 0, _chunkBQE3Y6ZOcjs.expandVectorAppearances.call(void 0, [now])[0]) : _chunkBQE3Y6ZOcjs.vectorPathWorldBezier.call(void 0, path);
     };
     const rest = lottieContours(_chunkGF2RBSDMcjs.toBezierPath.call(void 0, geometryAt(0)), round4);
-    rest.forEach((contour, n) => {
+    rest.forEach((contour, n2) => {
       let ks = { a: 0, k: contour };
       if (shapeSegments.length) {
         const keys = [];
@@ -3479,7 +3883,7 @@ function toLottie(scene, options = {}) {
         const count = Math.max(1, Math.ceil(end * fps / 1e3));
         for (let k = 0; k <= count && fits; k++) {
           const t = end * k / count;
-          const c = lottieContours(_chunkGF2RBSDMcjs.toBezierPath.call(void 0, geometryAt(t)), round4)[n];
+          const c = lottieContours(_chunkGF2RBSDMcjs.toBezierPath.call(void 0, geometryAt(t)), round4)[n2];
           if (!c || c.v.length !== contour.v.length || c.c !== contour.c) fits = false;
           else keys.push({ t: frame(t), s: [c], ...k < count ? { o: { x: [0], y: [0] }, i: { x: [1], y: [1] } } : {} });
         }
@@ -3488,7 +3892,7 @@ function toLottie(scene, options = {}) {
           sampled += keys.length;
         } else notes.push(`"${path.id}": its morph changes how many points the outline has, which Lottie cannot tween; it shows its starting shape.`);
       }
-      items.push({ ty: "sh", nm: `${path.id} ${n + 1}`, ks });
+      items.push({ ty: "sh", nm: `${path.id} ${n2 + 1}`, ks });
     });
     const fillFrom = owner(path, "fill");
     const strokeFrom = owner(path, "stroke");
@@ -3515,7 +3919,7 @@ function toLottie(scene, options = {}) {
         lj: path.strokeLinejoin === "round" ? 2 : path.strokeLinejoin === "bevel" ? 3 : 1,
         ml: 4
       });
-      if (_optionalChain([path, 'access', _153 => _153.strokeDasharray, 'optionalAccess', _154 => _154.length])) notes.push(`"${path.id}": its dashes are not exported; the stroke is solid.`);
+      if (_optionalChain([path, 'access', _174 => _174.strokeDasharray, 'optionalAccess', _175 => _175.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);
@@ -3532,7 +3936,7 @@ function toLottie(scene, options = {}) {
     }
     return items;
   };
-  const shown = (list) => list.filter((n) => n.visible !== false);
+  const shown = (list) => list.filter((n2) => n2.visible !== false);
   const nodeGroup = (node) => {
     const entry = nodes.get(node.id);
     if (timeline.tracks.has(motionTrackKey(node.id, "clipRect")) || timeline.tracks.has(motionTrackKey(node.id, "clipCircle")))
@@ -3567,9 +3971,9 @@ function toLottie(scene, options = {}) {
   const camera = track("", "camera");
   const root = STATIC_TR();
   if (camera.length) {
-    const box = (t) => _nullishCoalesce(trackValue(camera, t), () => ( [0, 0, artwork.width, artwork.height]));
-    root.a = animate(camera, (t) => box(t).slice(0, 2), false);
-    root.s = animate(camera, (t) => [artwork.width / box(t)[2] * 100, artwork.height / box(t)[3] * 100], false);
+    const box2 = (t) => _nullishCoalesce(trackValue(camera, t), () => ( [0, 0, artwork.width, artwork.height]));
+    root.a = animate(camera, (t) => box2(t).slice(0, 2), false);
+    root.s = animate(camera, (t) => [artwork.width / box2(t)[2] * 100, artwork.height / box2(t)[3] * 100], false);
   }
   const op = Math.max(1, Math.ceil(end * fps / 1e3));
   const lottie = {
@@ -3609,9 +4013,9 @@ var kids = (el, name) => el ? Array.from(el.children).filter((c) => c.localName
 var kid = (el, name) => _nullishCoalesce(kids(el, name)[0], () => ( null));
 var deep = (el, name) => el ? Array.from(el.getElementsByTagNameNS("*", name)) : [];
 var num = (el, attr, fallback = 0) => {
-  const v = _optionalChain([el, 'optionalAccess', _155 => _155.getAttribute, 'call', _156 => _156(attr)]);
-  const n = v === null || v === void 0 ? NaN : Number(v);
-  return Number.isFinite(n) ? n : fallback;
+  const v = _optionalChain([el, 'optionalAccess', _176 => _176.getAttribute, 'call', _177 => _177(attr)]);
+  const n2 = v === null || v === void 0 ? NaN : Number(v);
+  return Number.isFinite(n2) ? n2 : fallback;
 };
 var dirname = (p) => p.slice(0, p.lastIndexOf("/") + 1);
 function resolve(base, target) {
@@ -3717,8 +4121,8 @@ function placement(xfrm, map) {
   const ext = kid(xfrm, "ext");
   const [x, y, w, h] = map(num(off, "x"), num(off, "y"), num(ext, "cx"), num(ext, "cy"));
   const rot = num(xfrm, "rot") / 6e4 * (Math.PI / 180);
-  const fx = _optionalChain([xfrm, 'optionalAccess', _157 => _157.getAttribute, 'call', _158 => _158("flipH")]) === "1" ? -1 : 1;
-  const fy = _optionalChain([xfrm, 'optionalAccess', _159 => _159.getAttribute, 'call', _160 => _160("flipV")]) === "1" ? -1 : 1;
+  const fx = _optionalChain([xfrm, 'optionalAccess', _178 => _178.getAttribute, 'call', _179 => _179("flipH")]) === "1" ? -1 : 1;
+  const fy = _optionalChain([xfrm, 'optionalAccess', _180 => _180.getAttribute, 'call', _181 => _181("flipV")]) === "1" ? -1 : 1;
   const cx = x + w / 2;
   const cy = y + h / 2;
   const cos = Math.cos(rot);
@@ -3745,7 +4149,7 @@ function shapes(ctx, tree, map) {
     const nv = el.firstElementChild;
     const cNvPr = kid(nv, "cNvPr");
     const spid = num(cNvPr, "id", -1);
-    const name = _nullishCoalesce(_optionalChain([cNvPr, 'optionalAccess', _161 => _161.getAttribute, 'call', _162 => _162("name")]), () => ( ""));
+    const name = _nullishCoalesce(_optionalChain([cNvPr, 'optionalAccess', _182 => _182.getAttribute, 'call', _183 => _183("name")]), () => ( ""));
     if (el.localName === "grpSp") {
       const xfrm = kid(kid(el, "grpSpPr"), "xfrm");
       const off = kid(xfrm, "off");
@@ -3766,7 +4170,7 @@ function shapes(ctx, tree, map) {
     if (el.localName !== "sp" && el.localName !== "cxnSp") continue;
     const spPr = kid(el, "spPr");
     const { w, h, transform } = placement(kid(spPr, "xfrm"), map);
-    const prst = _optionalChain([kid, 'call', _163 => _163(spPr, "prstGeom"), 'optionalAccess', _164 => _164.getAttribute, 'call', _165 => _165("prst")]);
+    const prst = _optionalChain([kid, 'call', _184 => _184(spPr, "prstGeom"), 'optionalAccess', _185 => _185.getAttribute, 'call', _186 => _186("prst")]);
     const cust = kid(spPr, "custGeom");
     let subpaths = cust ? custom(cust, w, h) : prst ? preset(prst, w, h) : null;
     if (!subpaths) {
@@ -3880,13 +4284,13 @@ function command(ctx, ctn, scene, artwork, target, hidden) {
   }
   if (cls === "path") {
     const motion = deep(ctn, "animMotion")[0];
-    const d = _optionalChain([motion, 'optionalAccess', _166 => _166.getAttribute, 'call', _167 => _167("path")]);
+    const d = _optionalChain([motion, 'optionalAccess', _187 => _187.getAttribute, 'call', _188 => _188("path")]);
     if (!d) return null;
-    const entry = artwork.flatMap(function all(n) {
-      return n.type === "group" ? [n, ...n.children.flatMap(all)] : [n];
-    }).find((n) => n.id === target);
-    const t = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _168 => _168.transform]), () => ( [1, 0, 0, 1, 0, 0]));
-    const p = _optionalChain([entry, 'optionalAccess', _169 => _169.type]) === "path" ? _optionalChain([entry, 'access', _170 => _170.subpaths, 'access', _171 => _171[0], 'optionalAccess', _172 => _172.anchors]) : void 0;
+    const entry = artwork.flatMap(function all(n2) {
+      return n2.type === "group" ? [n2, ...n2.children.flatMap(all)] : [n2];
+    }).find((n2) => n2.id === target);
+    const t = _nullishCoalesce(_optionalChain([entry, 'optionalAccess', _189 => _189.transform]), () => ( [1, 0, 0, 1, 0, 0]));
+    const p = _optionalChain([entry, 'optionalAccess', _190 => _190.type]) === "path" ? _optionalChain([entry, 'access', _191 => _191.subpaths, 'access', _192 => _192[0], 'optionalAccess', _193 => _193.anchors]) : void 0;
     const xs = (_nullishCoalesce(p, () => ( []))).map((a) => a.x);
     const ys = (_nullishCoalesce(p, () => ( []))).map((a) => a.y);
     const lx = xs.length ? (Math.min(...xs) + Math.max(...xs)) / 2 : 0;
@@ -3929,8 +4333,8 @@ async function fromPptxAnimation(data, options = {}) {
   if (!pres) throw new Error("This is not a PowerPoint file (.pptx): it has no ppt/presentation.xml.");
   const presRels = await rels(ctx, "ppt/presentation.xml");
   const slidePaths = deep(pres, "sldId").map((s) => _nullishCoalesce(presRels.get(_nullishCoalesce(_nullishCoalesce(s.getAttributeNS("http://schemas.openxmlformats.org/officeDocument/2006/relationships", "id"), () => ( s.getAttribute("r:id"))), () => ( ""))), () => ( ""))).filter(Boolean);
-  const n = _nullishCoalesce(options.slide, () => ( 1));
-  if (!(Number.isInteger(n) && n >= 1 && n <= slidePaths.length)) throw new Error(`There is no slide ${n}; the file has ${slidePaths.length} slide${slidePaths.length === 1 ? "" : "s"}.`);
+  const n2 = _nullishCoalesce(options.slide, () => ( 1));
+  if (!(Number.isInteger(n2) && n2 >= 1 && n2 <= slidePaths.length)) throw new Error(`There is no slide ${n2}; the file has ${slidePaths.length} slide${slidePaths.length === 1 ? "" : "s"}.`);
   const size = deep(pres, "sldSz")[0];
   const width = Math.round(num(size, "cx", 12192e3) / EMU);
   const height = Math.round(num(size, "cy", 6858e3) / EMU);
@@ -3938,15 +4342,15 @@ async function fromPptxAnimation(data, options = {}) {
     if (!path.includes("theme/")) continue;
     const theme = await xml(ctx, path);
     const scheme = deep(theme, "clrScheme")[0];
-    for (const c of Array.from(_nullishCoalesce(_optionalChain([scheme, 'optionalAccess', _173 => _173.children]), () => ( [])))) {
+    for (const c of Array.from(_nullishCoalesce(_optionalChain([scheme, 'optionalAccess', _194 => _194.children]), () => ( [])))) {
       const v = c.firstElementChild;
-      const hex = _optionalChain([v, 'optionalAccess', _174 => _174.localName]) === "srgbClr" ? v.getAttribute("val") : _optionalChain([v, 'optionalAccess', _175 => _175.getAttribute, 'call', _176 => _176("lastClr")]);
+      const hex = _optionalChain([v, 'optionalAccess', _195 => _195.localName]) === "srgbClr" ? v.getAttribute("val") : _optionalChain([v, 'optionalAccess', _196 => _196.getAttribute, 'call', _197 => _197("lastClr")]);
       if (hex) ctx.theme.set(c.localName, `#${hex.toLowerCase()}`);
     }
     break;
   }
-  const slide = await xml(ctx, slidePaths[n - 1]);
-  if (!slide) throw new Error(`Slide ${n} cannot be read.`);
+  const slide = await xml(ctx, slidePaths[n2 - 1]);
+  if (!slide) throw new Error(`Slide ${n2} cannot be read.`);
   const tree = deep(slide, "spTree")[0];
   const toPx = (x, y, w, h) => [x / EMU, y / EMU, w / EMU, h / EMU];
   const nodes = tree ? shapes(ctx, tree, toPx) : [];
@@ -3973,18 +4377,118 @@ async function fromPptxAnimation(data, options = {}) {
   }
   if (effects.length && !shots.length) ctx.notes.push("The slide's effects could not be read.");
   const artwork = { width, height, background: bg, nodes: [...nodes, ...hidden] };
-  const scene = { version: 1, name: `slide-${n}`, artwork, shots, ...shots.length > 1 ? { trigger: "click" } : {} };
+  const scene = { version: 1, name: `slide-${n2}`, artwork, shots, ...shots.length > 1 ? { trigger: "click" } : {} };
   const problems = motionSceneShapeProblems(scene);
   if (problems.length) throw new Error(`The imported scene is not well formed:
 ${problems.join("\n")}`);
   return { scene, notes: [...new Set(ctx.notes)], issues: checkMotionScene(scene), slides: slidePaths.length };
 }
 
+// src/animation-editor/layer-edit.ts
+function motionShotLayersInfo(scene, shot) {
+  const spans = motionLayerSpans(scene);
+  const timings = compileMotionScene(scene).shots;
+  return scene.shots.filter((s) => shot === void 0 || s.id === shot).map((s) => {
+    const timing = timings.find((t) => t.id === s.id);
+    return {
+      shot: s.id,
+      layers: spans.filter((sp) => sp.shot === s.id).map((sp) => ({ ...sp.layer, shot: s.id, index: sp.index, role: sp.role, start: sp.start, end: sp.end })),
+      transition: s.transition && timing.transitionEnd !== void 0 ? { ...s.transition, start: timing.start, end: timing.transitionEnd } : null
+    };
+  });
+}
+function findMotionShotLayer(scene, id) {
+  for (let shot = 0; shot < scene.shots.length; shot++) {
+    const index = (_nullishCoalesce(scene.shots[shot].layers, () => ( []))).findIndex((l) => l.id === id);
+    if (index >= 0) return { shot, index };
+  }
+  return null;
+}
+var motionLayerIds = (scene) => scene.shots.flatMap((s) => (_nullishCoalesce(s.layers, () => ( []))).map((l) => l.id));
+function freshMotionLayerId(scene, base = "layer") {
+  const used = new Set(motionLayerIds(scene));
+  for (let i = 1; ; i++) if (!used.has(`${base}${i}`)) return `${base}${i}`;
+}
+var kindHint = (d) => {
+  if (d.uses.includes("transition")) return "it is a transition: set it between shots with set_shot_transition";
+  if (d.kind === "camera") return "it is a camera move: set it with set_shot_camera_move";
+  if (d.kind === "motion") return "it animates artwork nodes: apply it with apply_effect";
+  return `its uses are ${d.uses.join(", ")}`;
+};
+function withPreset(d, preset2, values) {
+  if (preset2 === void 0) return values;
+  const p = d.presets.find((x) => x.name === preset2);
+  if (!p) throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" has no preset "${preset2}"; ${d.presets.length ? `its presets are ${d.presets.map((x) => `"${x.name}"`).join(", ")}` : "it has no presets"}.`, d.id);
+  return { ...p.values, ..._nullishCoalesce(values, () => ( {})) };
+}
+async function resolveMotionShotLayer(provider, layer) {
+  if (!layer.effect) {
+    if (!layer.subject) throw new Error('A layer needs an "effect", a "subject" or both.');
+    if (layer.preset !== void 0 || layer.values !== void 0) throw new Error('A bare subject has no controls; leave out "preset" and "values", or give an "effect".');
+    const { provider: _p, name: _n, ...rest } = layer;
+    return rest;
+  }
+  if (!provider) throw new (0, _chunkJAOSL334cjs.NoEffectsProviderError)();
+  const d = await provider.describe(layer.effect);
+  if (!_chunk6RZVFYGJcjs.effectLayerOffered.call(void 0, d)) throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) cannot be a layer; ${kindHint(d)}. A layer's effect is a generator, filter, overlay or title (search_effects with use "generator", "filter", "overlay" or "title").`, d.id);
+  const input = _chunk6RZVFYGJcjs.effectLayerInput.call(void 0, d);
+  if (layer.subject && !input) throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) draws its own picture and takes no subject; leave "subject" out, or pick a filter to change the subject.`, d.id);
+  if (!layer.subject && input && _optionalChain([d, 'access', _198 => _198.inputs, 'access', _199 => _199.find, 'call', _200 => _200((i) => i.name === input), 'optionalAccess', _201 => _201.required])) throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) changes a picture; give a "subject": { "image": url }, { "svg": markup }, { "text": words } or { "slot": name }.`, d.id);
+  const values = withPreset(d, layer.preset, layer.values);
+  _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, values);
+  const out = { ...layer, provider: provider.id, name: d.name };
+  if (values && Object.keys(values).length) out.values = values;
+  else delete out.values;
+  return out;
+}
+async function resolveMotionShotTransition(provider, transition) {
+  if (!provider) throw new (0, _chunkJAOSL334cjs.NoEffectsProviderError)();
+  const d = await provider.describe(transition.effect);
+  if (!d.uses.includes("transition") || d.kind === "camera") throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) is not a transition (${kindHint(d)}); search_effects with use "transition" lists them.`, d.id);
+  if (transition.ms !== void 0 && !(transition.ms > 0 && transition.ms <= 6e4)) throw new Error(`A transition's "ms" is from 1 to 60000; got ${transition.ms}.`);
+  const values = withPreset(d, transition.preset, transition.values);
+  _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, values);
+  const out = { ...transition, ms: _nullishCoalesce(transition.ms, () => ( _chunkJAOSL334cjs.EFFECT_TRANSITION_MS)), provider: provider.id, name: d.name };
+  if (values && Object.keys(values).length) out.values = values;
+  else delete out.values;
+  return out;
+}
+async function checkMotionShotLayers(scene, provider) {
+  const issues = [];
+  if (_optionalChain([scene, 'access', _202 => _202.shots, 'access', _203 => _203[0], 'optionalAccess', _204 => _204.transition])) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "transition-first-shot", `Shot "${scene.shots[0].id}" is the first shot, so its transition does not play; move it to a later shot or clear it.`, { shot: scene.shots[0].id }));
+  for (const shot of scene.shots)
+    for (const layer of _nullishCoalesce(shot.layers, () => ( [])))
+      if (layer.subject && "slot" in layer.subject) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "layer-slot-empty", `Layer "${layer.id}" shows slot "${layer.subject.slot}", which is empty; set its "subject" to a picture with update_shot_layer.`, { shot: shot.id, ids: [layer.id] }));
+  const effectLayers = scene.shots.flatMap((s) => (_nullishCoalesce(s.layers, () => ( []))).filter((l) => l.effect).map((l) => ({ shot: s.id, layer: l })));
+  const transitions = scene.shots.slice(1).filter((s) => s.transition);
+  if (!provider) {
+    if (effectLayers.length) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "layer-not-drawn", `Layers ${effectLayers.map((e) => `"${e.layer.id}"`).join(", ")} name provider effects, but no effects provider is set, so they are left out of frames; set a provider to draw them.`, { ids: effectLayers.map((e) => e.layer.id) }));
+    if (transitions.length) issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, "transition-not-played", `Shots ${transitions.map((s) => `"${s.id}"`).join(", ")} name transitions, but no effects provider is set, so they crossfade; set a provider to play them.`));
+    return issues;
+  }
+  for (const { shot, layer } of effectLayers) {
+    try {
+      await resolveMotionShotLayer(provider, layer);
+    } catch (error) {
+      const code = error.code === "invalid_values" || /preset/.test(error.message) ? "layer-effect-values" : "layer-effect-unknown";
+      issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, code, `Layer "${layer.id}": ${error.message}`, { shot, ids: [layer.id] }));
+    }
+  }
+  for (const shot of transitions) {
+    try {
+      await resolveMotionShotTransition(provider, shot.transition);
+    } catch (error) {
+      issues.push(_chunkDGWOGQJ5cjs.motionIssue.call(void 0, error.code === "invalid_values" ? "layer-effect-values" : "transition-unknown", error.message, { shot: shot.id }));
+    }
+  }
+  return issues;
+}
+
 // src/animation-editor/effects.ts
 var sourceOf = (c) => c.source;
 function motionSceneEffects(scene) {
   const out = /* @__PURE__ */ new Map();
-  const groups = new Set(scene.artwork.nodes.filter((n) => n.type === "group").map((n) => n.id));
+  const groups = new Set(scene.artwork.nodes.filter((n2) => n2.type === "group").map((n2) => n2.id));
   for (const shot of scene.shots) {
     for (const c of shot.run) {
       const s = sourceOf(c);
@@ -4005,7 +4509,7 @@ function motionSceneEffects(scene) {
 }
 function nextMotionEffectInstance(scene) {
   const used = /* @__PURE__ */ new Set([...motionSceneEffects(scene).map((e) => e.instance), ...scene.shots.map((s) => s.id)]);
-  const walk = (nodes) => nodes.forEach((n) => (used.add(n.id), n.type === "group" && walk(n.children)));
+  const walk = (nodes) => nodes.forEach((n2) => (used.add(n2.id), n2.type === "group" && walk(n2.children)));
   walk(scene.artwork.nodes);
   for (let i = 1; ; i++) if (!used.has(`fx${i}`)) return `fx${i}`;
 }
@@ -4021,10 +4525,10 @@ function motionCommandsFromEffect(artwork, motion, source) {
 }
 function prefixed(nodes, shots, prefix) {
   const map = /* @__PURE__ */ new Map();
-  const rename = (list) => list.map((n) => {
-    map.set(n.id, prefix + n.id);
-    const next = { ...n, id: prefix + n.id };
-    if (next.type === "group") next.children = rename(n.children);
+  const rename = (list) => list.map((n2) => {
+    map.set(n2.id, prefix + n2.id);
+    const next = { ...n2, id: prefix + n2.id };
+    if (next.type === "group") next.children = rename(n2.children);
     return next;
   });
   const out = rename(nodes);
@@ -4040,14 +4544,14 @@ function prefixed(nodes, shots, prefix) {
   }));
   return { nodes: out, shots: remapped };
 }
-function motionPartsFromVectorEffect(artwork, motion, source, box = { x: 0, y: 0, width: artwork.width, height: artwork.height }) {
+function motionPartsFromVectorEffect(artwork, motion, source, box2 = { x: 0, y: 0, width: artwork.width, height: artwork.height }) {
   const imported = fromFlairSvgMotion({ svg: motion.svg, animate: [..._nullishCoalesce(motion.animate, () => ( []))] }, { hold: 0 });
   const art = imported.scene.artwork;
   const prefix = `${source.instance}-`;
   const { nodes, shots } = prefixed(art.nodes, imported.scene.shots, prefix);
-  const k = Math.min(box.width / art.width, box.height / art.height);
-  const dx = box.x + (box.width - art.width * k) / 2;
-  const dy = box.y + (box.height - art.height * k) / 2;
+  const k = Math.min(box2.width / art.width, box2.height / art.height);
+  const dx = box2.x + (box2.width - art.width * k) / 2;
+  const dy = box2.y + (box2.height - art.height * k) / 2;
   const group = { type: "group", id: source.instance, name: _nullishCoalesce(source.name, () => ( source.effect)), children: nodes, transform: [k, 0, 0, k, dx, dy] };
   const tagged = shots.map((s, i) => ({ ...s, id: i === 0 ? source.instance + "-shot" : `${source.instance}-shot-${i + 1}`, run: tag(s.run, source) }));
   return { group, shots: tagged.map((s) => s.hold === 0 ? (({ hold: _h, ...rest }) => rest)(s) : s), notes: imported.notes };
@@ -4058,7 +4562,7 @@ function withoutMotionEffect(scene, instance) {
   const shots = [];
   for (const shot of scene.shots) {
     const run = shot.run.filter((c, i) => {
-      const mine = _optionalChain([sourceOf, 'call', _177 => _177(c), 'optionalAccess', _178 => _178.instance]) === instance;
+      const mine = _optionalChain([sourceOf, 'call', _205 => _205(c), 'optionalAccess', _206 => _206.instance]) === instance;
       if (mine && !place) place = { shot: shot.id, index: i };
       return !mine;
     });
@@ -4066,7 +4570,7 @@ function withoutMotionEffect(scene, instance) {
     else if (run.length === 0) removedShots.push(shot.id);
     else shots.push({ ...shot, run });
   }
-  const artwork = { ...scene.artwork, nodes: scene.artwork.nodes.filter((n) => n.id !== instance) };
+  const artwork = { ...scene.artwork, nodes: scene.artwork.nodes.filter((n2) => n2.id !== instance) };
   return { scene: { ...scene, shots, artwork }, place, removedShots };
 }
 
@@ -4074,30 +4578,37 @@ function withoutMotionEffect(scene, instance) {
 var MOTION_RECORD_GESTURE_MODES = ["move", "scale", "rotate"];
 var MOTION_MAX_TAKE_MS = 10 * 6e4;
 var BLANK = { width: 800, height: 450, background: "#ffffff", nodes: [] };
-var AnimationEditorController = (_class = class {
+var AnimationEditorController = (_class2 = class {
   
   
   /** The effects provider slot (see `setEffectsProvider`). */
-  __init() {this.effects = new (0, _chunk2K5TELHVcjs.EffectsSlot)()}
+  __init8() {this.effects = new (0, _chunkJAOSL334cjs.EffectsSlot)()}
+  /** Renders shot layer and transition pictures for frames (see `MotionLayersEngine`). */
+  
   
   
-  __init2() {this.selection = null}
+  __init9() {this.selection = null}
   
-  __init3() {this.error = null}
-  __init4() {this.revision = 0}
-  __init5() {this.applying = false}
+  __init10() {this.error = null}
+  __init11() {this.revision = 0}
+  __init12() {this.applying = false}
   
-  __init6() {this.listeners = /* @__PURE__ */ new Set()}
-  __init7() {this.unsubscribers = []}
+  __init13() {this.listeners = /* @__PURE__ */ new Set()}
+  __init14() {this.unsubscribers = []}
   
-  __init8() {this.recording = null}
-  constructor(options = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);_class.prototype.__init8.call(this);_class.prototype.__init9.call(this);_class.prototype.__init10.call(this);
+  __init15() {this.recording = null}
+  constructor(options = {}) {;_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this);_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this);_class2.prototype.__init17.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkFJ2MSI43cjs.HistoryManager)()));
     this.scene = options.scene ? parseMotionScene(options.scene) : createMotionScene(BLANK);
     this.issues = checkMotionScene(this.scene);
     this.readOnly = _nullishCoalesce(options.readOnly, () => ( false));
     this.onChange = options.onChange;
     if (options.effects) this.effects.set(options.effects);
+    this.layers = new MotionLayersEngine({
+      slot: this.effects,
+      host: options.layerHost === void 0 ? browserMotionLayerHost() : options.layerHost,
+      frameSvg: (scene, time) => motionFrameToSvg(scene, time, { effects: this.effects.provider, layers: this.layers, transitions: false, pretty: false })
+    });
     this.player = new (0, _chunkM5GLQQWGcjs.AnimationPlayer)({ clock: options.clock, duration: () => compileMotionScene(this.scene).duration, loop: _nullishCoalesce(this.scene.loop, () => ( "none")) });
     this.state = this.computeState();
     this.connect();
@@ -4109,7 +4620,8 @@ var AnimationEditorController = (_class = class {
       this.history.subscribe(() => {
         if (!this.applying) this.notify();
       }),
-      this.effects.subscribe(() => this.notify())
+      this.effects.subscribe(() => this.notify()),
+      this.layers.subscribe(() => this.notify())
     );
   }
   /**
@@ -4121,8 +4633,8 @@ var AnimationEditorController = (_class = class {
     this.player.pause();
     this.unsubscribers.splice(0).forEach((u) => u());
   }
-  __init9() {this.getState = () => this.state}
-  __init10() {this.subscribe = (listener) => {
+  __init16() {this.getState = () => this.state}
+  __init17() {this.subscribe = (listener) => {
     this.connect();
     this.listeners.add(listener);
     return () => {
@@ -4145,7 +4657,7 @@ var AnimationEditorController = (_class = class {
       time: p.time,
       playing: p.playing,
       loop: p.loop,
-      currentShot: _nullishCoalesce(_optionalChain([motionShotAt, 'call', _179 => _179(timeline, p.time), 'optionalAccess', _180 => _180.id]), () => ( null)),
+      currentShot: _nullishCoalesce(_optionalChain([motionShotAt, 'call', _207 => _207(timeline, p.time), 'optionalAccess', _208 => _208.id]), () => ( null)),
       selection: this.selection,
       readOnly: this.readOnly,
       error: this.error,
@@ -4193,7 +4705,7 @@ var AnimationEditorController = (_class = class {
       this.applying = false;
     }
     this.notify();
-    _optionalChain([this, 'access', _181 => _181.onChange, 'optionalCall', _182 => _182(scene)]);
+    _optionalChain([this, 'access', _209 => _209.onChange, 'optionalCall', _210 => _210(scene)]);
   }
   commit(label, next, merge) {
     const before = this.scene;
@@ -4228,10 +4740,10 @@ var AnimationEditorController = (_class = class {
   apply(edits, label = "Edit animation", options = {}) {
     const reason = _nullishCoalesce(this.readOnlyReason(), () => ( (this.recording ? "A take is being recorded; stop or cancel the recording first." : null)));
     if (reason) return this.refuse(reason);
-    const result = applyMotionEdits(this.scene, edits);
-    if (!result.ok) return options.dryRun ? result : this.refuse(result.error);
-    if (!options.dryRun) this.commit(label, result.scene, options.merge);
-    return result;
+    const result2 = applyMotionEdits(this.scene, edits);
+    if (!result2.ok) return options.dryRun ? result2 : this.refuse(result2.error);
+    if (!options.dryRun) this.commit(label, result2.scene, options.merge);
+    return result2;
   }
   /** Replaces the artwork (e.g. from a vector editor's `onChange`), as one undo step. */
   setArtwork(artwork, label = "Change artwork") {
@@ -4263,7 +4775,7 @@ var AnimationEditorController = (_class = class {
     try {
       plan = await work();
     } catch (error) {
-      if (_chunk2K5TELHVcjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
+      if (_chunkJAOSL334cjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
       throw error;
     }
     const r = this.apply({ op: "replace_scene", scene: plan.scene }, plan.label, { merge });
@@ -4274,17 +4786,17 @@ var AnimationEditorController = (_class = class {
   }
   async describeFor(effect, kinds) {
     const provider = this.effects.require();
-    if (!provider.applyVectorEffect) throw new (0, _chunk2K5TELHVcjs.EffectUnsupportedError)(`${provider.name} has no vector or motion effects.`);
+    if (!provider.applyVectorEffect) throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`${provider.name} has no vector or motion effects.`);
     const d = await provider.describe(effect);
     if (!kinds.includes(d.kind)) {
       const hint = d.kind === "motion" ? "apply it to nodes with apply_effect" : d.kind === "vector" ? "add it with add_vector_effect" : "it draws pixels, which scenes cannot hold";
-      throw new (0, _chunk2K5TELHVcjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) is a ${d.kind} effect: ${hint}.`, d.id);
+      throw new (0, _chunkJAOSL334cjs.EffectUnsupportedError)(`"${d.id}" (${d.name}) is a ${d.kind} effect: ${hint}.`, d.id);
     }
     return d;
   }
   knownNodes(ids) {
     const all = /* @__PURE__ */ new Set();
-    const walk = (nodes) => nodes.forEach((n) => (all.add(n.id), n.type === "group" && walk(n.children)));
+    const walk = (nodes) => nodes.forEach((n2) => (all.add(n2.id), n2.type === "group" && walk(n2.children)));
     walk(this.scene.artwork.nodes);
     const missing = ids.filter((id) => !all.has(id));
     if (missing.length) throw new Error(`The artwork has no node ${missing.map((m) => `"${m}"`).join(", ")}; get_animation lists the node ids.`);
@@ -4299,7 +4811,7 @@ var AnimationEditorController = (_class = class {
     return this.effectEdit(async () => {
       this.knownNodes(targets);
       const d = await this.describeFor(effect, ["motion"]);
-      const values = _chunk2K5TELHVcjs.resolveEffectValues.call(void 0, d, options.values);
+      const values = _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, options.values);
       const instance = _nullishCoalesce(options.instance, () => ( nextMotionEffectInstance(this.scene)));
       const motion = await this.effects.require().applyVectorEffect(d.id, { svg: motionArtworkSvg(this.scene.artwork), nodeIds: [...targets] }, values);
       const source = { instance, effect: d.id, provider: this.effects.require().id, name: d.name, values };
@@ -4321,7 +4833,7 @@ var AnimationEditorController = (_class = class {
   addVectorEffect(effect, options = {}) {
     return this.effectEdit(async () => {
       const d = await this.describeFor(effect, ["vector"]);
-      const values = _chunk2K5TELHVcjs.resolveEffectValues.call(void 0, d, options.values);
+      const values = _chunkJAOSL334cjs.resolveEffectValues.call(void 0, d, options.values);
       const instance = _nullishCoalesce(options.instance, () => ( nextMotionEffectInstance(this.scene)));
       const motion = await this.effects.require().applyVectorEffect(d.id, motionArtworkSvg(this.scene.artwork), values);
       const source = { instance, effect: d.id, provider: this.effects.require().id, name: d.name, values };
@@ -4345,17 +4857,17 @@ var AnimationEditorController = (_class = class {
         else if (k in d.controls.properties) base[k] = d.defaults[k];
         else throw new Error(`"${k}" is not a control of "${d.id}"; its controls are ${Object.keys(d.controls.properties).join(", ")}.`);
       }
-      const merged = { ...base, ..._chunk2K5TELHVcjs.resolveEffectValues.call(void 0, { ...d, defaults: base }, given) };
+      const merged = { ...base, ..._chunkJAOSL334cjs.resolveEffectValues.call(void 0, { ...d, defaults: base }, given) };
       const { scene: bare, place } = withoutMotionEffect(this.scene, instance);
       const provider = this.effects.require();
       const source = { instance, effect: d.id, provider: provider.id, name: d.name, values: merged };
       if (was.kind === "vector") {
-        const old = this.scene.artwork.nodes.find((n) => n.id === instance);
+        const old = this.scene.artwork.nodes.find((n2) => n2.id === instance);
         const motion2 = await provider.applyVectorEffect(d.id, motionArtworkSvg(bare.artwork), merged);
         const { group, shots: shots2, notes: notes2 } = motionPartsFromVectorEffect(bare.artwork, motion2, source);
-        const index = this.scene.artwork.nodes.findIndex((n) => n.id === instance);
+        const index = this.scene.artwork.nodes.findIndex((n2) => n2.id === instance);
         const nodes = [...bare.artwork.nodes];
-        nodes.splice(Math.max(0, index), 0, _optionalChain([old, 'optionalAccess', _183 => _183.transform]) ? { ...group, transform: old.transform } : group);
+        nodes.splice(Math.max(0, index), 0, _optionalChain([old, 'optionalAccess', _211 => _211.transform]) ? { ...group, transform: old.transform } : group);
         const at = this.scene.shots.findIndex((s) => was.shots.includes(s.id));
         const kept = bare.shots;
         const nextShots = [...kept.slice(0, Math.max(0, at)), ...shots2, ...kept.slice(Math.max(0, at))];
@@ -4366,7 +4878,7 @@ var AnimationEditorController = (_class = class {
       let shots = bare.shots;
       if (place && shots.some((s) => s.id === place.shot)) shots = shots.map((s) => s.id === place.shot ? { ...s, run: [...s.run.slice(0, place.index), ...commands, ...s.run.slice(place.index)] } : s);
       else {
-        const at = this.scene.shots.findIndex((s) => s.id === _optionalChain([place, 'optionalAccess', _184 => _184.shot]));
+        const at = this.scene.shots.findIndex((s) => s.id === _optionalChain([place, 'optionalAccess', _212 => _212.shot]));
         shots = [...shots.slice(0, Math.max(0, at)), { id: instance, label: d.name, run: commands }, ...shots.slice(Math.max(0, at))];
       }
       return { scene: { ...bare, shots }, label: `Change ${d.name}`, instance, notes };
@@ -4400,12 +4912,12 @@ var AnimationEditorController = (_class = class {
     if (!found) return this.refuse(`There is no shot "${shot}"; the shots are ${this.scene.shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
     let resolved;
     try {
-      resolved = await _chunk2K5TELHVcjs.resolveCameraMoveSpec.call(void 0, this.effects.require(), spec, role);
+      resolved = await _chunkJAOSL334cjs.resolveCameraMoveSpec.call(void 0, this.effects.require(), spec, role);
     } catch (error) {
-      if (_chunk2K5TELHVcjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
+      if (_chunkJAOSL334cjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
       throw error;
     }
-    const field = _chunk2K5TELHVcjs.cameraMoveField.call(void 0, role);
+    const field = _chunkJAOSL334cjs.cameraMoveField.call(void 0, role);
     const current = this.scene.shots.find((s) => s.id === shot);
     if (!current) return this.refuse(`Shot "${shot}" was removed while the move was checked.`);
     const parts = role === "transition" && resolved.spec.ms === void 0 ? { ...resolved.spec, ms: resolved.description.camera.durationMs } : resolved.spec;
@@ -4419,8 +4931,8 @@ var AnimationEditorController = (_class = class {
   clearShotCameraMove(shot, role) {
     const found = this.scene.shots.find((s) => s.id === shot);
     if (!found) return this.refuse(`There is no shot "${shot}"; the shots are ${this.scene.shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
-    const field = _chunk2K5TELHVcjs.cameraMoveField.call(void 0, role);
-    if (_optionalChain([found, 'access', _185 => _185.camera, 'optionalAccess', _186 => _186[field]]) === void 0) return this.refuse(`Shot "${shot}" has no camera "${field}" move to clear${_optionalChain([found, 'access', _187 => _187.camera, 'optionalAccess', _188 => _188[field === "in" ? "during" : "in"]]) !== void 0 ? `; it has a "${field === "in" ? "during" : "in"}" move (role ${role === "hold" ? "transition" : "hold"})` : ""}.`);
+    const field = _chunkJAOSL334cjs.cameraMoveField.call(void 0, role);
+    if (_optionalChain([found, 'access', _213 => _213.camera, 'optionalAccess', _214 => _214[field]]) === void 0) return this.refuse(`Shot "${shot}" has no camera "${field}" move to clear${_optionalChain([found, 'access', _215 => _215.camera, 'optionalAccess', _216 => _216[field === "in" ? "during" : "in"]]) !== void 0 ? `; it has a "${field === "in" ? "during" : "in"}" move (role ${role === "hold" ? "transition" : "hold"})` : ""}.`);
     const rest = { ...found.camera };
     delete rest[field];
     const keep = motionCameraFramed(rest) || rest.in !== void 0 || rest.during !== void 0;
@@ -4430,7 +4942,7 @@ var AnimationEditorController = (_class = class {
   }
   cameraMoveResult(shot, role, move) {
     const timing = compileMotionScene(this.scene).shots.find((s) => s.id === shot);
-    const camera = _nullishCoalesce(_optionalChain([this, 'access', _189 => _189.scene, 'access', _190 => _190.shots, 'access', _191 => _191.find, 'call', _192 => _192((s) => s.id === shot), 'optionalAccess', _193 => _193.camera]), () => ( null));
+    const camera = _nullishCoalesce(_optionalChain([this, 'access', _217 => _217.scene, 'access', _218 => _218.shots, 'access', _219 => _219.find, 'call', _220 => _220((s) => s.id === shot), 'optionalAccess', _221 => _221.camera]), () => ( null));
     const window = role === "transition" ? { start: timing.start, end: timing.commandsStart } : { start: timing.commandsEnd, end: timing.end };
     const notes = [];
     if (move && role === "transition" && timing.index === 0) notes.push('This is the first shot, which cuts to its framing, so its "in" move does not play; it plays from the second shot on.');
@@ -4501,7 +5013,7 @@ var AnimationEditorController = (_class = class {
   viewScene() {
     const r = this.recording;
     if (!r) return this.scene;
-    if (_optionalChain([r, 'access', _194 => _194.preview, 'optionalAccess', _195 => _195.count]) === r.samples.length) return r.preview.scene;
+    if (_optionalChain([r, 'access', _222 => _222.preview, 'optionalAccess', _223 => _223.count]) === r.samples.length) return r.preview.scene;
     let scene = this.scene;
     if (r.samples.length) {
       try {
@@ -4517,9 +5029,151 @@ var AnimationEditorController = (_class = class {
   frame(time = this.player.currentTime, options = {}) {
     return motionFrameAt(this.viewScene(), time, { effects: this.effects.provider, ...options });
   }
-  /** The scene at `time` (default: the playhead) as SVG. */
+  /**
+   * The scene at `time` (default: the playhead) as SVG. Shot layer and transition pictures that
+   * are not rendered yet are left out (a transition crossfades) and come in on a later frame;
+   * `toSvgExact` waits for them.
+   */
   toSvg(time = this.player.currentTime, options = {}) {
-    return motionStageSvg(this.viewScene(), time, { effects: this.effects.provider, ...options });
+    return motionStageSvg(this.viewScene(), time, { effects: this.effects.provider, layers: this.layers, ...options });
+  }
+  /** Like `toSvg`, once every shot layer and transition picture of the frame is rendered (or has failed). */
+  async toSvgExact(time = this.player.currentTime, options = {}) {
+    let svg = this.toSvg(time, options);
+    for (let pass = 0; pass < 8 && this.layers.busy; pass++) {
+      await this.layers.idle();
+      svg = this.toSvg(time, options);
+    }
+    return svg;
+  }
+  // ---------------------------------------------------------------------------------------
+  // Shot layers and transitions
+  // ---------------------------------------------------------------------------------------
+  /** Every shot's layers and transition (or one shot's). Throws for an unknown shot, naming the shots. */
+  shotLayers(shot) {
+    if (shot !== void 0 && !this.scene.shots.some((s) => s.id === shot)) throw new Error(this.noShot(shot));
+    return motionShotLayersInfo(this.scene, shot);
+  }
+  noShot(shot) {
+    return `There is no shot "${shot}"; the shots are ${this.scene.shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`;
+  }
+  noLayer(layer) {
+    const ids = this.scene.shots.flatMap((s) => (_nullishCoalesce(s.layers, () => ( []))).map((l) => `"${l.id}"`));
+    return `There is no layer "${layer}"; ${ids.length ? `the layers are ${ids.join(", ")}` : "the scene has no layers yet (add_shot_layer adds one)"}.`;
+  }
+  layerResult(shot, layerId, notes = []) {
+    const info2 = motionShotLayersInfo(this.scene, shot)[0];
+    const layer = layerId ? info2.layers.find((l) => l.id === layerId) : void 0;
+    return { ok: true, ...info2, ...layer ? { layer } : {}, notes };
+  }
+  async layerEdit(work, merge) {
+    const reason = this.readOnlyReason();
+    if (reason) return this.refuse(reason);
+    let plan;
+    try {
+      plan = await work();
+    } catch (error) {
+      if (_chunkJAOSL334cjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
+      throw error;
+    }
+    const id = this.scene.shots[plan.shot].id;
+    const r = this.apply(plan.layers.length ? { op: "update_shot", shot: id, set: { layers: plan.layers } } : { op: "update_shot", shot: id, remove: ["layers"] }, plan.label, { merge });
+    if (!r.ok) return r;
+    return this.layerResult(id, plan.layer, plan.notes);
+  }
+  /**
+   * Adds a layer to a shot: a provider effect (a generator, filter, overlay or title), optionally
+   * applied to a `subject`, or a bare subject. Checked against the provider first; at `index`
+   * (default the top). One undo step. Returns the layer (with its id) and the shot's layers.
+   */
+  addShotLayer(shot, layer, options = {}) {
+    return this.layerEdit(async () => {
+      const at = this.scene.shots.findIndex((s) => s.id === shot);
+      if (at < 0) throw new Error(this.noShot(shot));
+      const id = _nullishCoalesce(layer.id, () => ( freshMotionLayerId(this.scene)));
+      if (findMotionShotLayer(this.scene, id)) throw new Error(`Layer id "${id}" is already used; choose another (e.g. "${freshMotionLayerId(this.scene)}").`);
+      const resolved = await resolveMotionShotLayer(this.effects.provider, { ...layer, id });
+      const layers = [..._nullishCoalesce(this.scene.shots[at].layers, () => ( []))];
+      const index = _nullishCoalesce(options.index, () => ( layers.length));
+      if (!Number.isInteger(index) || index < 0 || index > layers.length) throw new Error(`"index" must be a whole number from 0 to ${layers.length} (got ${index}).`);
+      layers.splice(index, 0, resolved);
+      const notes = resolved.subject && "slot" in resolved.subject ? [`The subject is slot "${resolved.subject.slot}", which draws nothing until it is filled; set "subject" with update_shot_layer.`] : [];
+      return { shot: at, layers, label: `Add layer ${_nullishCoalesce(resolved.name, () => ( id))}`, layer: id, notes };
+    });
+  }
+  /** Changes a layer's fields (`null` clears an optional one); the result is checked against the provider. One undo step (`merge` folds a slider drag into one). */
+  updateShotLayer(layer, changes, options = {}) {
+    return this.layerEdit(async () => {
+      const found = findMotionShotLayer(this.scene, layer);
+      if (!found) throw new Error(this.noLayer(layer));
+      const was = this.scene.shots[found.shot].layers[found.index];
+      const next = { ...was };
+      for (const [k, v] of Object.entries(changes)) {
+        if (v === null) delete next[k];
+        else if (v !== void 0) next[k] = v;
+      }
+      if (changes.effect !== void 0 && changes.effect !== was.effect && changes.values === void 0) delete next.values;
+      const resolved = await resolveMotionShotLayer(this.effects.provider, next);
+      const layers = this.scene.shots[found.shot].layers.map((l, i) => i === found.index ? resolved : l);
+      return { shot: found.shot, layers, label: `Change layer ${_nullishCoalesce(resolved.name, () => ( layer))}`, layer };
+    }, options.merge);
+  }
+  /** Removes a layer. One undo step. Works without a provider. */
+  removeShotLayer(layer) {
+    return this.layerEdit(async () => {
+      const found = findMotionShotLayer(this.scene, layer);
+      if (!found) throw new Error(this.noLayer(layer));
+      const layers = this.scene.shots[found.shot].layers.filter((_, i) => i !== found.index);
+      return { shot: found.shot, layers, label: "Remove layer" };
+    });
+  }
+  /** Moves a layer to `index` in its shot (0 = bottom). One undo step. */
+  moveShotLayer(layer, index) {
+    return this.layerEdit(async () => {
+      const found = findMotionShotLayer(this.scene, layer);
+      if (!found) throw new Error(this.noLayer(layer));
+      const layers = [...this.scene.shots[found.shot].layers];
+      if (!Number.isInteger(index) || index < 0 || index >= layers.length) throw new Error(`"index" must be a whole number from 0 to ${layers.length - 1} (got ${index}).`);
+      const [moved] = layers.splice(found.index, 1);
+      layers.splice(index, 0, moved);
+      return { shot: found.shot, layers, label: "Move layer", layer };
+    });
+  }
+  /**
+   * Sets the provider transition into a shot from the shot before (not the first shot). Checked
+   * against the provider (its use, preset and values; its length is written out). With no camera
+   * move in, the camera cuts. One undo step (`merge` folds a slider drag into one).
+   */
+  async setShotTransition(shot, transition, options = {}) {
+    const reason = this.readOnlyReason();
+    if (reason) return this.refuse(reason);
+    const at = this.scene.shots.findIndex((s) => s.id === shot);
+    if (at < 0) return this.refuse(this.noShot(shot));
+    if (at === 0) return this.refuse(`Shot "${shot}" is the first shot, so there is no shot before it to transition from; set the transition on a later shot${this.scene.shots[1] ? ` (e.g. "${this.scene.shots[1].id}")` : ""}.`);
+    let resolved;
+    try {
+      const { provider: _p, name: _n, ...given } = transition;
+      resolved = await resolveMotionShotTransition(this.effects.provider, given);
+    } catch (error) {
+      if (_chunkJAOSL334cjs.isEffectError.call(void 0, error) || error instanceof Error) return this.refuse(error.message);
+      throw error;
+    }
+    if (!this.scene.shots.some((s) => s.id === shot)) return this.refuse(`Shot "${shot}" was removed while the transition was checked.`);
+    const r = this.apply({ op: "update_shot", shot, set: { transition: resolved } }, `Transition ${_nullishCoalesce(resolved.name, () => ( resolved.effect))}`, { merge: options.merge });
+    if (!r.ok) return r;
+    const camera = this.scene.shots.find((s) => s.id === shot).camera;
+    return this.layerResult(shot, void 0, _optionalChain([camera, 'optionalAccess', _224 => _224.in]) === void 0 ? ["With no camera move in, the camera cuts to this shot's framing and the transition does the move."] : []);
+  }
+  /** Removes a shot's transition. One undo step. Works without a provider. */
+  clearShotTransition(shot) {
+    const reason = this.readOnlyReason();
+    if (reason) return this.refuse(reason);
+    const found = this.scene.shots.find((s) => s.id === shot);
+    if (!found) return this.refuse(this.noShot(shot));
+    if (!found.transition) return this.refuse(`Shot "${shot}" has no transition to clear.`);
+    const r = this.apply({ op: "update_shot", shot, remove: ["transition"] }, "Clear transition");
+    if (!r.ok) return r;
+    return this.layerResult(shot, void 0);
   }
   // ---------------------------------------------------------------------------------------
   // Recording
@@ -4568,8 +5222,8 @@ var AnimationEditorController = (_class = class {
     return motionNodePose(this.viewScene(), node, time);
   }
   /** A point on a stage element (client pixels, e.g. a pointer event) in document units, through the camera now. */
-  clientToDocument(box, clientX, clientY) {
-    return motionClientToDocument(this.frame().camera, box, clientX, clientY);
+  clientToDocument(box2, clientX, clientY) {
+    return motionClientToDocument(this.frame().camera, box2, clientX, clientY);
   }
   /**
    * Starts a stage drag while recording: from `point` (document units), `move` drags the node,
@@ -4586,13 +5240,13 @@ var AnimationEditorController = (_class = class {
   }
   /** Records the drag's pose with the pointer at `point` (document units). */
   updateRecordGesture(point) {
-    const g = _optionalChain([this, 'access', _196 => _196.recording, 'optionalAccess', _197 => _197.gesture]);
+    const g = _optionalChain([this, 'access', _225 => _225.recording, 'optionalAccess', _226 => _226.gesture]);
     if (g) this.recordGesture(g.pose, point);
   }
   /** Ends the stage drag (the take keeps recording). */
   endRecordGesture() {
     const r = this.recording;
-    if (!_optionalChain([r, 'optionalAccess', _198 => _198.gesture])) return;
+    if (!_optionalChain([r, 'optionalAccess', _227 => _227.gesture])) return;
     r.gesture = null;
     this.notify();
   }
@@ -4606,7 +5260,7 @@ var AnimationEditorController = (_class = class {
       this.recordSample(g.node, { scaleX: Math.max(0.01, pose.scaleX * f), scaleY: Math.max(0.01, pose.scaleY * f) });
     } else {
       const turn = (Math.atan2(point.y - c.y, point.x - c.x) - Math.atan2(g.from.y - c.y, g.from.x - c.x)) * (180 / Math.PI);
-      const was = _nullishCoalesce(_optionalChain([this, 'access', _199 => _199.recording, 'access', _200 => _200.samples, 'access', _201 => _201.filter, 'call', _202 => _202((s) => s.node === g.node && s.rotation !== void 0), 'access', _203 => _203.at, 'call', _204 => _204(-1), 'optionalAccess', _205 => _205.rotation]), () => ( pose.rotation));
+      const was = _nullishCoalesce(_optionalChain([this, 'access', _228 => _228.recording, 'access', _229 => _229.samples, 'access', _230 => _230.filter, 'call', _231 => _231((s) => s.node === g.node && s.rotation !== void 0), 'access', _232 => _232.at, 'call', _233 => _233(-1), 'optionalAccess', _234 => _234.rotation]), () => ( pose.rotation));
       let next = pose.rotation + turn;
       next += 360 * Math.round((was - next) / 360);
       this.recordSample(g.node, { rotation: next });
@@ -4633,9 +5287,9 @@ var AnimationEditorController = (_class = class {
       this.player.seek(r.start);
       return this.refuse("Nothing was recorded, so no shot was added: drag an element on the stage (or change its paint) while recording.");
     }
-    const result = this.recordTake({ samples: r.samples, length }, r.options);
+    const result2 = this.recordTake({ samples: r.samples, length }, r.options);
     this.player.seek(r.start);
-    return result;
+    return result2;
   }
   /** Stops recording and throws the take away. */
   cancelRecording() {
@@ -4655,10 +5309,10 @@ var AnimationEditorController = (_class = class {
     } catch (error) {
       return options.dryRun ? { ok: false, error: error.message } : this.refuse(error.message);
     }
-    const result = this.apply({ op: "insert_shots", shots: [made.shot], at: made.at }, "Record take", { dryRun: options.dryRun });
-    if (!result.ok) return result;
+    const result2 = this.apply({ op: "insert_shots", shots: [made.shot], at: made.at }, "Record take", { dryRun: options.dryRun });
+    if (!result2.ok) return result2;
     if (!options.dryRun) this.select({ shot: made.shot.id });
-    return { ok: true, ...made, issues: result.issues };
+    return { ok: true, ...made, issues: result2.issues };
   }
   /** The scene as a Flair `SvgMotion`. */
   toFlairMotion(options = {}) {
@@ -4672,7 +5326,7 @@ var AnimationEditorController = (_class = class {
   toFlairDocument(options = {}) {
     return toFlairEffectDocument(this.scene, { effects: this.effects.provider, ...options });
   }
-}, _class);
+}, _class2);
 
 // src/animation-editor/playback.ts
 var str = (v) => typeof v === "string" && v.length > 0;
@@ -4700,7 +5354,7 @@ function elementsOf(args) {
   if (Array.isArray(args.ops)) {
     for (const op of args.ops) {
       fromShot(op);
-      if (Array.isArray(_optionalChain([op, 'optionalAccess', _206 => _206.shots]))) op.shots.forEach(fromShot);
+      if (Array.isArray(_optionalChain([op, 'optionalAccess', _235 => _235.shots]))) op.shots.forEach(fromShot);
     }
   }
   return out.slice(0, 4);
@@ -4882,7 +5536,7 @@ var MOTION_COMMAND_SCHEMA = {
   oneOf: MOTION_COMMAND_TYPES.map((type) => MOTION_COMMAND_TYPE_SCHEMAS[type])
 };
 var REF2 = (name, description) => ({ $ref: `#/$defs/${name}`, ...description ? { description } : {} });
-var firstSentence = (text) => _nullishCoalesce(_optionalChain([/^.*?[.;](?=\s|$)/, 'access', _207 => _207.exec, 'call', _208 => _208(text), 'optionalAccess', _209 => _209[0]]), () => ( text));
+var firstSentence = (text) => _nullishCoalesce(_optionalChain([/^.*?[.;](?=\s|$)/, 'access', _236 => _236.exec, 'call', _237 => _237(text), 'optionalAccess', _238 => _238[0]]), () => ( text));
 var COMMAND_TYPE_LINES = MOTION_COMMAND_TYPES.map((type) => `${type}: ${firstSentence(_nullishCoalesce(MOTION_COMMAND_TYPE_SCHEMAS[type].description, () => ( "")))}`);
 var EASE_COMPACT = {
   description: `Easing: a preset, or a curve { "type": "cubic-bezier", x1, y1, x2, y2 }, { "type": "spring", stiffness, damping, mass, velocity } (spring presets are Figma's; with no "duration" it lasts until it settles) or { "type": "elastic", amplitude, period, mode }. Default: ease-out for entrances, ease-in-out for moves.`,
@@ -5019,7 +5673,7 @@ function withDefs(schema) {
   };
   visit(schema);
   if (!used.size) return schema;
-  return { ...schema, $defs: Object.fromEntries(Object.keys(DEFS).filter((n) => used.has(n)).map((n) => [n, DEFS[n]])) };
+  return { ...schema, $defs: Object.fromEntries(Object.keys(DEFS).filter((n2) => used.has(n2)).map((n2) => [n2, DEFS[n2]])) };
 }
 var SETTINGS = {
   name: { type: "string", minLength: 1, description: 'Short name, e.g. "logo-reveal".' },
@@ -5084,7 +5738,7 @@ function describeElement(node, ancestors) {
     ...effects.length ? { effects } : {}
   };
 }
-var round3 = (n) => Math.round(n * 10) / 10;
+var round3 = (n2) => Math.round(n2 * 10) / 10;
 function describeMotionElements(scene) {
   return [...indexMotionNodes(scene.artwork.nodes).values()].map((e) => ({
     ...describeElement(e.node, e.ancestors),
@@ -5116,7 +5770,7 @@ var issueSummary = (issues) => ({
   errors: issues.filter((i) => i.severity === "error").length,
   warnings: issues.filter((i) => i.severity === "warning").length,
   notes: issues.filter((i) => i.severity === "note").length,
-  lines: issues.map((i) => `${i.severity}: ${_chunkERJA5CGTcjs.motionIssueLine.call(void 0, i)}`)
+  lines: issues.map((i) => `${i.severity}: ${_chunkDGWOGQJ5cjs.motionIssueLine.call(void 0, i)}`)
 });
 function createAnimationEditorToolProvider(controller, options = {}) {
   const readOnlyReason = () => {
@@ -5125,20 +5779,20 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     return controller.readOnlyReason();
   };
   const scene = () => controller.getScene();
-  const outcome = (result, extra = {}) => {
-    if (!result.ok) throw new Error(result.error);
-    const timeline = compileMotionScene(result.scene);
+  const outcome = (result2, extra = {}) => {
+    if (!result2.ok) throw new Error(result2.error);
+    const timeline = compileMotionScene(result2.scene);
     return {
       ...extra,
       duration: timeline.duration,
       shots: timeline.shots.map((s) => ({ id: s.id, start: s.start, end: s.end })),
-      issues: issueSummary(result.issues),
-      ...result.hints.length ? { hints: result.hints } : {}
+      issues: issueSummary(result2.issues),
+      ...result2.hints.length ? { hints: result2.hints } : {}
     };
   };
   const apply = (edits, label, extra) => {
-    const result = controller.apply(edits, label);
-    return outcome(result, result.ok && extra ? extra(result.scene) : {});
+    const result2 = controller.apply(edits, label);
+    return outcome(result2, result2.ok && extra ? extra(result2.scene) : {});
   };
   const getAnimation = {
     name: "get_animation",
@@ -5180,7 +5834,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     annotations: { title: "Describe command types", ...READ },
     handler: ({ types }) => {
       for (const type of types)
-        if (!MOTION_COMMAND_TYPES.includes(type)) throw new Error(`There is no command type ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, type, MOTION_COMMAND_TYPES)}; use one of ${MOTION_COMMAND_TYPES.join(", ")}.`);
+        if (!MOTION_COMMAND_TYPES.includes(type)) throw new Error(`There is no command type ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, type, MOTION_COMMAND_TYPES)}; use one of ${MOTION_COMMAND_TYPES.join(", ")}.`);
       return { commands: types.map((type) => ({ type, schema: MOTION_COMMAND_TYPE_SCHEMAS[type] })) };
     }
   };
@@ -5253,7 +5907,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
       }
       if (Array.isArray(motion_paths)) {
         const known = new Set(describeMotionElements(s).map((e) => e.id));
-        for (const id of motion_paths) if (!known.has(id)) throw new Error(`There is no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, known)} to draw a motion path for.`);
+        for (const id of motion_paths) if (!known.has(id)) throw new Error(`There is no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, known)} to draw a motion path for.`);
       }
       const overlays = { ...onion_skin ? { onionSkin: onion_skin } : {}, ...motion_paths ? { motionPaths: motion_paths } : {} };
       if (times) {
@@ -5266,7 +5920,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
         }
         return { times, svg: sheet };
       }
-      const svg = controller.toSvg(t, { pretty: false, ...overlays });
+      const svg = await controller.toSvgExact(t, { pretty: false, ...overlays });
       if (format === "png") {
         if (!options.rasterize) throw new Error('This host cannot make PNG images; call render_animation_frame with format "svg".');
         const image = await options.rasterize(svg, { width: s.artwork.width, height: s.artwork.height });
@@ -5291,9 +5945,9 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ from = 0, to, limit = 200 }) => {
       const s = scene();
       const timeline = compileMotionScene(s);
-      const words = _nullishCoalesce(_optionalChain([s, 'access', _210 => _210.narration, 'optionalAccess', _211 => _211.words]), () => ( []));
+      const words = _nullishCoalesce(_optionalChain([s, 'access', _239 => _239.narration, 'optionalAccess', _240 => _240.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 = (ms2) => _optionalChain([timeline, 'access', _212 => _212.shots, 'access', _213 => _213.find, 'call', _214 => _214((x) => ms2 >= x.start && ms2 < x.end), 'optionalAccess', _215 => _215.id]);
+      const shotAt = (ms2) => _optionalChain([timeline, 'access', _241 => _241.shots, 'access', _242 => _242.find, 'call', _243 => _243((x) => ms2 >= x.start && ms2 < x.end), 'optionalAccess', _244 => _244.id]);
       const beats = [];
       if (s.beat && s.beat.bpm > 0) {
         const first = Math.max(0, Math.ceil(motionBeatAt(s.beat, from).beat - 1e-9));
@@ -5323,10 +5977,10 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ group }) => {
       const s = scene();
       const nodes = indexMotionNodes(s.artwork.nodes);
-      if (!nodes.has(group)) throw new Error(`There is no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, group, [...nodes.keys()])}.`);
+      if (!nodes.has(group)) throw new Error(`There is no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, group, [...nodes.keys()])}.`);
       const layout = motionTextLayout(nodes, group);
       if (!layout) throw new Error(`"${group}" is not a group of paths; convert the text to outlines (one path a letter) and group it.`);
-      return { group, letters: layout.lines.reduce((n, l) => n + l.words.reduce((m, w) => m + w.letters.length, 0), 0), ...layout };
+      return { group, letters: layout.lines.reduce((n2, l) => n2 + l.words.reduce((m, w) => m + w.letters.length, 0), 0), ...layout };
     }
   };
   const getMotionPath = {
@@ -5343,7 +5997,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ node, from, to, step }) => {
       const s = scene();
       const ids = describeMotionElements(s).map((e) => e.id);
-      if (!ids.includes(node)) throw new Error(`There is no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, node, ids)}.`);
+      if (!ids.includes(node)) throw new Error(`There is no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, node, ids)}.`);
       return motionPath(s, node, { from, to, step });
     }
   };
@@ -5415,17 +6069,17 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     ),
     annotations: { title: "Import a PowerPoint slide's animation", ...DESTRUCTIVE },
     handler: async ({ data, slide, dry_run = false }) => {
-      let result;
+      let result2;
       try {
         const bytes = Uint8Array.from(atob(data.replace(/\s+/g, "")), (c) => c.charCodeAt(0));
-        result = await fromPptxAnimation(bytes, slide ? { slide } : {});
+        result2 = await fromPptxAnimation(bytes, slide ? { slide } : {});
       } catch (error) {
         throw new Error(`The slide could not be imported: ${error.message} Nothing was changed.`);
       }
-      const report = { slides: result.slides, notes: result.notes, issues: issueSummary(result.issues), shots: describeMotionShots(result.scene).map(({ id, start, end, commands }) => ({ id, start, end, commands: commands.length })) };
+      const report = { slides: result2.slides, notes: result2.notes, issues: issueSummary(result2.issues), shots: describeMotionShots(result2.scene).map(({ id, start, end, commands }) => ({ id, start, end, commands: commands.length })) };
       if (dry_run) return { dry_run: true, ...report, hint: "Nothing was replaced; call again without dry_run to import." };
-      const applied = controller.apply({ op: "replace_scene", scene: result.scene }, "Import PowerPoint slide");
-      return outcome(applied, applied.ok ? { ...report, elements: describeMotionElements(result.scene) } : {});
+      const applied = controller.apply({ op: "replace_scene", scene: result2.scene }, "Import PowerPoint slide");
+      return outcome(applied, applied.ok ? { ...report, elements: describeMotionElements(result2.scene) } : {});
     }
   };
   const importFlairEffect = {
@@ -5444,16 +6098,16 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     annotations: { title: "Import a Flair effect", ...DESTRUCTIVE },
     handler: ({ effect, motion, name, dry_run = false }) => {
       if (effect === void 0 === (motion === void 0)) throw new Error('Give exactly one of "effect" (a Flair vector effect) or "motion" (a Flair SvgMotion). Nothing was changed.');
-      let result;
+      let result2;
       try {
-        result = effect !== void 0 ? fromFlairVectorEffect(effect, name ? { name } : {}) : fromFlairSvgMotion(motion, name ? { name } : {});
+        result2 = effect !== void 0 ? fromFlairVectorEffect(effect, name ? { name } : {}) : fromFlairSvgMotion(motion, name ? { name } : {});
       } catch (error) {
         throw new Error(`The Flair effect could not be imported: ${error.message} Nothing was changed.`);
       }
-      const report = { notes: result.notes, issues: issueSummary(result.issues), shots: describeMotionShots(result.scene).map(({ id, start, end, commands }) => ({ id, start, end, commands: commands.length })) };
+      const report = { notes: result2.notes, issues: issueSummary(result2.issues), shots: describeMotionShots(result2.scene).map(({ id, start, end, commands }) => ({ id, start, end, commands: commands.length })) };
       if (dry_run) return { dry_run: true, ...report, hint: "Nothing was replaced; call again without dry_run to import." };
-      const applied = controller.apply({ op: "replace_scene", scene: result.scene }, "Import Flair effect");
-      return outcome(applied, applied.ok ? { ...report, elements: describeMotionElements(result.scene) } : {});
+      const applied = controller.apply({ op: "replace_scene", scene: result2.scene }, "Import Flair effect");
+      return outcome(applied, applied.ok ? { ...report, elements: describeMotionElements(result2.scene) } : {});
     }
   };
   const fitAnimation = {
@@ -5516,18 +6170,18 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     ),
     annotations: { title: "Record a performed take", ...WRITE },
     handler: ({ samples, length, id, label, at, tolerance, dry_run = false }) => {
-      const result = controller.recordTake({ samples, length }, { id, label, at, tolerance, dryRun: dry_run });
-      if (!result.ok) throw new Error(result.error);
+      const result2 = controller.recordTake({ samples, length }, { id, label, at, tolerance, dryRun: dry_run });
+      if (!result2.ok) throw new Error(result2.error);
       const s = dry_run ? scene() : controller.getScene();
-      const report = { shot: result.shot.id, at: result.at, start: Math.round(result.start), samples: result.samples };
-      if (dry_run) return { dry_run: true, ...report, run: result.shot.run, hold: result.shot.hold, hint: "Nothing was changed; call again without dry_run to add the shot." };
+      const report = { shot: result2.shot.id, at: result2.at, start: Math.round(result2.start), samples: result2.samples };
+      if (dry_run) return { dry_run: true, ...report, run: result2.shot.run, hold: result2.shot.hold, hint: "Nothing was changed; call again without dry_run to add the shot." };
       const timeline = compileMotionScene(s);
-      const described = describeMotionShots(s).find((x) => x.id === result.shot.id);
+      const described = describeMotionShots(s).find((x) => x.id === result2.shot.id);
       return {
         ...report,
         commands: described.commands.map((c) => ({ index: c.index, type: c.type, targets: "targets" in c ? c.targets : [], start: c.start, end: c.end })),
         duration: timeline.duration,
-        issues: issueSummary(result.issues)
+        issues: issueSummary(result2.issues)
       };
     }
   };
@@ -5595,27 +6249,27 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ from, to, shots, stagger }) => {
       const s = scene();
       const ids = describeMotionElements(s).map((e) => e.id);
-      for (const id of [from, ...to]) if (!ids.includes(id)) throw new Error(`There is no element ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, ids)}. Nothing was changed.`);
+      for (const id of [from, ...to]) if (!ids.includes(id)) throw new Error(`There is no element ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, ids)}. Nothing was changed.`);
       if (to.includes(from)) throw new Error(`"to" includes "${from}" itself; give other elements. Nothing was changed.`);
       const only = shots ? new Set(shots) : null;
       if (only) {
-        for (const id of only) if (!s.shots.some((x) => x.id === id)) throw new Error(`There is no shot ${_chunkERJA5CGTcjs.namedWithSuggestion.call(void 0, id, s.shots.map((x) => x.id))}. Nothing was changed.`);
+        for (const id of only) if (!s.shots.some((x) => x.id === id)) throw new Error(`There is no shot ${_chunkDGWOGQJ5cjs.namedWithSuggestion.call(void 0, id, s.shots.map((x) => x.id))}. Nothing was changed.`);
       }
       const copied = {};
       const edits = [];
       for (const shot of s.shots) {
         if (only && !only.has(shot.id)) continue;
         const run = [];
-        let n = 0;
+        let n2 = 0;
         for (const c of shot.run) {
           run.push(c);
           if (c.type === "wait" || !c.targets.includes(from)) continue;
           const { delay: _delay, ...rest } = c;
           run.push({ ...rest, targets: to, with: "previous", ...stagger ? { stagger } : {} });
-          n++;
+          n2++;
         }
-        if (n) {
-          copied[shot.id] = n;
+        if (n2) {
+          copied[shot.id] = n2;
           edits.push({ op: "update_shot", shot: shot.id, set: { run } });
         }
       }
@@ -5669,7 +6323,7 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     inputSchema: object({ shot: SHOT_ID, commands: { type: "array", items: REF2("command"), 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', _216 => _216(), 'access', _217 => _217.shots, 'access', _218 => _218.find, 'call', _219 => _219((s) => s.id === shot), 'optionalAccess', _220 => _220.run, 'access', _221 => _221.length]), () => ( 0));
+      const before = _nullishCoalesce(_optionalChain([scene, 'call', _245 => _245(), 'access', _246 => _246.shots, 'access', _247 => _247.find, 'call', _248 => _248((s) => s.id === shot), 'optionalAccess', _249 => _249.run, 'access', _250 => _250.length]), () => ( 0));
       const first = _nullishCoalesce(at, () => ( before));
       return apply({ op: "add_commands", shot, commands, at }, "Add commands", (s) => {
         const shots = describeMotionShots(s);
@@ -5742,8 +6396,8 @@ function createAnimationEditorToolProvider(controller, options = {}) {
     handler: ({ ops, dry_run = false }) => {
       const refs = resolveMotionEditRefs(controller.getScene(), ops);
       if (!refs.ok) throw new Error(refs.error);
-      const result = controller.apply(refs.edits, "Edit animation", { dryRun: dry_run });
-      return outcome(result, { outcomes: refs.outcomes, ...dry_run ? { dry_run: true, hint: "Nothing was applied; call again without dry_run to apply." } : {} });
+      const result2 = controller.apply(refs.edits, "Edit animation", { dryRun: dry_run });
+      return outcome(result2, { outcomes: refs.outcomes, ...dry_run ? { dry_run: true, hint: "Nothing was applied; call again without dry_run to apply." } : {} });
     }
   };
   const writeAnimation = {
@@ -5870,7 +6524,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', _222 => _222.properties, 'optionalAccess', _223 => _223.type, 'optionalAccess', _224 => _224.const]) === type);
+  return (_nullishCoalesce(MOTION_COMMAND_SCHEMA.oneOf, () => ( []))).find((b) => _optionalChain([b, 'access', _251 => _251.properties, 'optionalAccess', _252 => _252.type, 'optionalAccess', _253 => _253.const]) === type);
 }
 function unitOf(type, name) {
   if (name === "duration" || name === "delay" || name === "stagger") return "ms";
@@ -5905,9 +6559,9 @@ function kindOf(name, schema) {
 }
 function motionCommandFields(type) {
   const schema = branch(type);
-  if (!_optionalChain([schema, 'optionalAccess', _225 => _225.properties])) return [];
+  if (!_optionalChain([schema, 'optionalAccess', _254 => _254.properties])) return [];
   const required = new Set(_nullishCoalesce(schema.required, () => ( [])));
-  const fields = Object.entries(schema.properties).filter(([name]) => name !== "type").map(([name, s]) => {
+  const fields2 = Object.entries(schema.properties).filter(([name]) => name !== "type").map(([name, s]) => {
     const kind = kindOf(name, s);
     const min = typeof s.minimum === "number" ? s.minimum : typeof s.exclusiveMinimum === "number" ? s.exclusiveMinimum : void 0;
     return {
@@ -5923,7 +6577,7 @@ function motionCommandFields(type) {
       group: TIMING.has(name) ? "timing" : "main"
     };
   });
-  return [...fields.filter((f) => f.group === "main"), ...fields.filter((f) => f.group === "timing")];
+  return [...fields2.filter((f) => f.group === "main"), ...fields2.filter((f) => f.group === "timing")];
 }
 function parseMotionFieldInput(field, raw) {
   if (field.kind === "boolean") return raw === true ? { set: true } : { remove: true };
@@ -5942,12 +6596,12 @@ function parseMotionFieldInput(field, raw) {
   const text = String(raw).trim();
   if (text === "") return field.required ? { error: `${field.label} is required.` } : { remove: true };
   if (field.kind === "number" || field.kind === "integer" || field.kind === "scale") {
-    const n = Number(text);
-    if (!Number.isFinite(n)) return { error: `${field.label} must be a number${field.unit ? ` (${field.unit})` : ""}.` };
-    if (field.kind === "integer" && !Number.isInteger(n)) return { error: `${field.label} must be a whole number.` };
-    if (field.min !== void 0 && n < field.min) return { error: `${field.label} must be at least ${field.min}.` };
-    if (field.max !== void 0 && n > field.max) return { error: `${field.label} must be at most ${field.max}.` };
-    return { set: n };
+    const n2 = Number(text);
+    if (!Number.isFinite(n2)) return { error: `${field.label} must be a number${field.unit ? ` (${field.unit})` : ""}.` };
+    if (field.kind === "integer" && !Number.isInteger(n2)) return { error: `${field.label} must be a whole number.` };
+    if (field.min !== void 0 && n2 < field.min) return { error: `${field.label} must be at least ${field.min}.` };
+    if (field.max !== void 0 && n2 > field.max) return { error: `${field.label} must be at most ${field.max}.` };
+    return { set: n2 };
   }
   if (field.kind === "enum" && field.options && !field.options.includes(text)) return { error: `${field.label} must be one of ${field.options.join(", ")}.` };
   return { set: text };
@@ -5962,7 +6616,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', _226 => _226.find, 'call', _227 => _227((e) => !targets.includes(e.node.id) && pred(e)), 'optionalAccess', _228 => _228.node, 'access', _229 => _229.id]);
+  const other = (pred) => _optionalChain([nodes, 'access', _255 => _255.find, 'call', _256 => _256((e) => !targets.includes(e.node.id) && pred(e)), 'optionalAccess', _257 => _257.node, 'access', _258 => _258.id]);
   const base = { targets: [...targets] };
   switch (type) {
     case "scale":
@@ -5993,8 +6647,8 @@ function defaultMotionCommand(type, targets, scene) {
     }
     case "effect": {
       for (const id of targets) {
-        const node = _optionalChain([nodes, 'access', _230 => _230.find, 'call', _231 => _231((e) => e.node.id === id), 'optionalAccess', _232 => _232.node]);
-        for (const effect of _nullishCoalesce(_optionalChain([node, 'optionalAccess', _233 => _233.effects]), () => ( []))) {
+        const node = _optionalChain([nodes, 'access', _259 => _259.find, 'call', _260 => _260((e) => e.node.id === id), 'optionalAccess', _261 => _261.node]);
+        for (const effect of _nullishCoalesce(_optionalChain([node, 'optionalAccess', _262 => _262.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 };
         }
@@ -6019,11 +6673,11 @@ function motionCommandRows(scene, shotId) {
   return scene.shots[index].run.map((command3, i) => {
     const t = timeline.commands.find((c) => c.shotIndex === index && c.command === i);
     const primitive = motionFlairPrimitive(command3);
-    return { index: i, command: command3, summary: motionCommandSummary(command3), start: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _234 => _234.start]), () => ( 0)), end: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _235 => _235.end]), () => ( 0)), ...primitive ? { flairPrimitive: primitive } : {} };
+    return { index: i, command: command3, summary: motionCommandSummary(command3), start: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _263 => _263.start]), () => ( 0)), end: _nullishCoalesce(_optionalChain([t, 'optionalAccess', _264 => _264.end]), () => ( 0)), ...primitive ? { flairPrimitive: primitive } : {} };
   });
 }
 function duplicateMotionCommandEdit(scene, shot, command3) {
-  const run = _nullishCoalesce(_optionalChain([scene, 'access', _236 => _236.shots, 'access', _237 => _237.find, 'call', _238 => _238((s) => s.id === shot), 'optionalAccess', _239 => _239.run]), () => ( []));
+  const run = _nullishCoalesce(_optionalChain([scene, 'access', _265 => _265.shots, 'access', _266 => _266.find, 'call', _267 => _267((s) => s.id === shot), 'optionalAccess', _268 => _268.run]), () => ( []));
   return { op: "add_commands", shot, commands: run[command3] ? [structuredClone(run[command3])] : [], at: command3 + 1 };
 }
 var MOTION_EASE_CHOICES = [
@@ -6037,18 +6691,18 @@ function motionEaseKey(ease) {
 function motionEasingCurve(ease, samples = 48, durationMs = 1e3) {
   const resolved = _chunkDWJJI6RTcjs.resolveEasing.call(void 0, ease);
   const ms2 = resolved !== "hold" && resolved.type === "spring" ? _chunkDWJJI6RTcjs.springSettleMs.call(void 0, resolved) : durationMs;
-  const n = Math.max(2, Math.floor(samples));
+  const n2 = Math.max(2, Math.floor(samples));
   const points = [];
-  for (let i = 0; i <= n; i++) {
-    const u = i / n;
-    points.push({ u, v: resolved === "hold" ? i === n ? 1 : 0 : _chunkDWJJI6RTcjs.evaluateEasing.call(void 0, ease, u, ms2) });
+  for (let i = 0; i <= n2; i++) {
+    const u = i / n2;
+    points.push({ u, v: resolved === "hold" ? i === n2 ? 1 : 0 : _chunkDWJJI6RTcjs.evaluateEasing.call(void 0, ease, u, ms2) });
   }
   const values = points.map((p) => p.v);
   return { points, min: Math.min(0, ...values), max: Math.max(1, ...values), durationMs: ms2 };
 }
 function motionEasingPath(curve, width, height, pad = 4) {
   const span = curve.max - curve.min || 1;
-  const f = (n) => String(Math.round(n * 100) / 100);
+  const f = (n2) => String(Math.round(n2 * 100) / 100);
   return curve.points.map((p, i) => `${i ? "L" : "M"}${f(pad + p.u * (width - 2 * pad))} ${f(pad + (1 - (p.v - curve.min) / span) * (height - 2 * pad))}`).join(" ");
 }
 function motionEasingGuides(curve, height, pad = 4) {
@@ -6108,7 +6762,7 @@ function motionCueFromKey(key) {
 function motionCueChoices(scene, limit = 256) {
   const choices = [];
   const s = (ms2) => `${(ms2 / 1e3).toFixed(2)} s`;
-  const end = Math.max(compileMotionScene(scene).duration, ..._nullishCoalesce(_optionalChain([scene, 'access', _240 => _240.narration, 'optionalAccess', _241 => _241.words, 'access', _242 => _242.map, 'call', _243 => _243((w) => _nullishCoalesce(w.end, () => ( w.start)))]), () => ( [0]))) + 2e3;
+  const end = Math.max(compileMotionScene(scene).duration, ..._nullishCoalesce(_optionalChain([scene, 'access', _269 => _269.narration, 'optionalAccess', _270 => _270.words, 'access', _271 => _271.map, 'call', _272 => _272((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);
@@ -6118,7 +6772,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', _244 => _244.narration, 'optionalAccess', _245 => _245.words, 'access', _246 => _246.forEach, 'call', _247 => _247((w, i) => {
+  _optionalChain([scene, 'access', _273 => _273.narration, 'optionalAccess', _274 => _274.words, 'access', _275 => _275.forEach, 'call', _276 => _276((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;
@@ -6127,7 +6781,7 @@ function motionShotCueTime(scene, cue) {
   return cue ? motionCueTime(scene, cue) : void 0;
 }
 function formatMotionNarration(narration) {
-  return (_nullishCoalesce(_optionalChain([narration, 'optionalAccess', _248 => _248.words]), () => ( []))).map((w) => `${w.start} ${w.text}`).join("\n");
+  return (_nullishCoalesce(_optionalChain([narration, 'optionalAccess', _277 => _277.words]), () => ( []))).map((w) => `${w.start} ${w.text}`).join("\n");
 }
 function parseMotionNarration(text) {
   const lines = text.split("\n").map((l) => l.trim()).filter(Boolean);
@@ -6158,7 +6812,7 @@ function parseMotionDrivers(text) {
     if (factor !== void 0) d.factor = Number(factor);
     if (offset !== void 0) d.offset = (sign === "-" ? -1 : 1) * Number(offset);
     if (min !== void 0) d.clamp = [Number(min), Number(max)];
-    if ([d.factor, d.offset, ..._nullishCoalesce(d.clamp, () => ( []))].some((n) => n !== void 0 && !Number.isFinite(n))) return { error: `Line ${i + 1} has a number that cannot be read.` };
+    if ([d.factor, d.offset, ..._nullishCoalesce(d.clamp, () => ( []))].some((n2) => n2 !== void 0 && !Number.isFinite(n2))) return { error: `Line ${i + 1} has a number that cannot be read.` };
     drivers.push(d);
   }
   return { drivers };
@@ -6170,7 +6824,7 @@ var ROLE = {
   enum: ["transition", "hold"],
   description: `transition: the move the camera gets into the shot with (its camera "in": a glide, whip pan, punch zoom, cut). hold: the move it makes while the shot holds (its camera "during": a Ken Burns drift, a crash zoom), played across the shot's hold.`
 };
-var summary = (e) => ({ id: e.id, name: e.name, role: e.camera.role, durationMs: e.camera.durationMs, ...e.camera.cut !== void 0 ? { cut: e.camera.cut } : {}, ...e.description ? { description: e.description } : {}, ..._optionalChain([e, 'access', _249 => _249.tags, 'optionalAccess', _250 => _250.length]) ? { tags: e.tags } : {} });
+var summary = (e) => ({ id: e.id, name: e.name, role: e.camera.role, durationMs: e.camera.durationMs, ...e.camera.cut !== void 0 ? { cut: e.camera.cut } : {}, ...e.description ? { description: e.description } : {}, ..._optionalChain([e, 'access', _278 => _278.tags, 'optionalAccess', _279 => _279.length]) ? { tags: e.tags } : {} });
 var done = (r) => {
   if (!r.ok) throw new Error(r.error);
   return { shot: r.shot, camera: r.camera, ...r.window ? { window: r.window } : {}, ...r.notes.length ? { notes: r.notes } : {} };
@@ -6199,7 +6853,7 @@ function animationCameraMoveTools(controller, ctx) {
           shot: { type: "string", minLength: 1, description: "A shot id from get_animation." },
           role: ROLE,
           move: { type: "string", minLength: 1, description: "A camera move id of that role from list_camera_moves." },
-          ms: { type: "number", minimum: 0, maximum: _chunk2K5TELHVcjs.CAMERA_MOVE_MAX_MS, description: `How long a transition takes, ms (0\u2013${_chunk2K5TELHVcjs.CAMERA_MOVE_MAX_MS}; default the move's durationMs). Not for a hold, which plays across the shot's hold.` },
+          ms: { type: "number", minimum: 0, maximum: _chunkJAOSL334cjs.CAMERA_MOVE_MAX_MS, description: `How long a transition takes, ms (0\u2013${_chunkJAOSL334cjs.CAMERA_MOVE_MAX_MS}; default the move's durationMs). Not for a hold, which plays across the shot's hold.` },
           preset: { type: "string", minLength: 1, description: "A preset of the move by name, from describe_effect; its values are written out on the shot." },
           values: ctx.valuesSchema("Control values over the move's defaults (and the preset's), from describe_effect")
         },
@@ -6229,6 +6883,163 @@ function animationCameraMoveTools(controller, ctx) {
   ];
 }
 
+// src/animation-editor/layer-tools.ts
+var LAYER_USES = ["generator", "filter", "overlay", "title"];
+var SHOT2 = { type: "string", minLength: 1, description: "A shot id from get_animation." };
+var LAYER = { type: "string", minLength: 1, description: 'A layer id from list_shot_layers (e.g. "layer1").' };
+var SUBJECT = {
+  anyOf: [
+    { type: "object", properties: { image: { type: "string", minLength: 1, description: "A picture URL or data: URL." } }, required: ["image"], additionalProperties: false, description: '{ "image": url }' },
+    { type: "object", properties: { svg: { type: "string", minLength: 1, description: "SVG markup or an SVG URL." } }, required: ["svg"], additionalProperties: false, description: '{ "svg": markup }' },
+    {
+      type: "object",
+      properties: { text: { type: "string", minLength: 1, description: "The words." }, font: { type: "string", description: "A CSS font family (default system-ui)." }, weight: { anyOf: [{ type: "number" }, { type: "string" }], description: "A CSS font weight (default 700)." } },
+      required: ["text"],
+      additionalProperties: false,
+      description: '{ "text": words }'
+    },
+    { type: "object", properties: { slot: { type: "string", minLength: 1, description: "A slot name the host fills later." } }, required: ["slot"], additionalProperties: false, description: '{ "slot": name }: draws nothing until filled.' }
+  ],
+  description: "What the layer shows, or feeds its effect (a filter changes it): a picture, SVG, words, or a slot to fill later. Leave out for a generator, overlay or title that draws its own picture."
+};
+var RECT = {
+  type: "object",
+  properties: {
+    x: { type: "number", description: "Left edge, artwork units." },
+    y: { type: "number", description: "Top edge, artwork units." },
+    width: { type: "number", exclusiveMinimum: 0, description: "Width, artwork units." },
+    height: { type: "number", exclusiveMinimum: 0, description: "Height, artwork units." }
+  },
+  required: ["x", "y", "width", "height"],
+  additionalProperties: false,
+  description: "Where the layer sits on the artwork (it moves with the camera). Leave out to fill the screen."
+};
+var TIME = (what, fallback) => ({
+  anyOf: [
+    { type: "number", minimum: 0, description: "Ms after the shot starts." },
+    { type: "object", properties: { shots: { type: "integer", minimum: 1, description: "1: when the next shot starts; 2: the one after\u2026" } }, required: ["shots"], additionalProperties: false, description: '{ "shots": n }' }
+  ],
+  description: `When the layer ${what}: ms after its shot starts, or { "shots": n } for when the n-th shot after its own starts (default ${fallback}).`
+});
+var fields = (ctx) => ({
+  effect: { ...ctx.effectIdSchema(LAYER_USES), description: "A generator, filter, overlay or title effect id from search_effects. Leave out for a bare subject." },
+  preset: { type: "string", minLength: 1, description: "A preset of the effect by name, from describe_effect; its values are written out on the layer." },
+  values: ctx.valuesSchema("Control values over the effect's defaults (and the preset's), from describe_effect"),
+  subject: SUBJECT,
+  role: { type: "string", enum: [..._chunkJAOSL334cjs.EFFECT_LAYER_ROLES], description: "background: under the artwork; subject: over the artwork; overlay: over everything. Default subject with a rect, else background." },
+  rect: RECT,
+  from: TIME("starts", "0: as its shot starts"),
+  until: TIME("stops", '{ "shots": 1 }: as the next shot starts'),
+  opacity: { type: "number", minimum: 0, maximum: 1, description: "Opacity 0\u20131 (default 1)." },
+  fade: { type: "number", minimum: 0, maximum: 6e4, description: "Ms it fades in and out over (default 0: it cuts)." }
+});
+var result = (r) => {
+  if (!r.ok) throw new Error(r.error);
+  const { ok: _ok, notes, ...rest } = r;
+  return { ...rest, ...notes.length ? { notes } : {} };
+};
+function animationShotLayerTools(controller, ctx) {
+  const f = fields(ctx);
+  return [
+    {
+      name: "list_shot_layers",
+      title: "List shot layers",
+      description: "Lists the layers and transition of every shot, or of one: [{ shot, layers: [{ id, effect, name, subject, role, rect, from, until, opacity, fade, values, index (0 = bottom), start, end (ms when it shows) }], transition: { effect, ms, values, start, end } or null }]. Use the layer ids with update_shot_layer, move_shot_layer and remove_shot_layer. Works without a provider.",
+      inputSchema: { type: "object", properties: { shot: { ...SHOT2, description: "Only this shot (default every shot)." } }, additionalProperties: false },
+      annotations: { title: "List shot layers", ...ctx.annotations.read },
+      handler: async (args) => ({ shots: controller.shotLayers(args.shot) })
+    },
+    {
+      name: "add_shot_layer",
+      title: "Add a shot layer",
+      description: "Adds a layer to a shot: a provider effect (a generator such as a gradient background, a filter applied to a subject, an overlay or title) or a bare subject (a picture, SVG or words). It shows from its shot's start until the next shot starts unless from / until say otherwise, fills the screen unless given a rect, and goes on top unless given an index. Checked first: an effect that cannot be a layer (a transition, a camera move, a motion effect) is refused with the tool to use instead, as are a subject the effect cannot take, a filter without a subject, an unknown preset and values outside its controls. One undo step. Returns { shot, layer (with its id, start and end), layers (the shot's, bottom to top), transition, notes }. Check it with render_animation_frame.",
+      inputSchema: {
+        type: "object",
+        properties: { shot: SHOT2, ...f, id: { type: "string", pattern: "^[A-Za-z_][\\w.-]*$", description: "The layer's id (default layer1, layer2\u2026); unique in the scene." }, index: { type: "integer", minimum: 0, description: "Its place in the shot, 0 = bottom (default the top)." } },
+        required: ["shot"],
+        additionalProperties: false
+      },
+      annotations: { title: "Add a shot layer", ...ctx.annotations.write },
+      handler: async ({ shot, index, ...layer }) => {
+        if (layer.effect !== void 0) ctx.requireProvider();
+        if (layer.effect === void 0 && layer.subject === void 0) throw new Error('Give an "effect" (search_effects with use generator, filter, overlay or title), a "subject" (a picture, SVG or words), or both.');
+        return result(await controller.addShotLayer(shot, layer, { index }));
+      }
+    },
+    {
+      name: "update_shot_layer",
+      title: "Change a shot layer",
+      description: `Changes a layer's fields: give the ones to change, and list in "clear" the optional ones to remove (back to their defaults). A new effect starts from its own defaults unless values are given. Checked against the provider like add_shot_layer. One undo step. Returns { shot, layer, layers, transition }.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          layer: LAYER,
+          ...f,
+          clear: { type: "array", items: { type: "string", enum: ["effect", "preset", "values", "subject", "role", "rect", "from", "until", "opacity", "fade"] }, uniqueItems: true, description: "Fields to remove." }
+        },
+        required: ["layer"],
+        additionalProperties: false
+      },
+      annotations: { title: "Change a shot layer", ...ctx.annotations.writeIdempotent },
+      handler: async ({ layer, clear, ...set }) => {
+        const changes = { ...set };
+        for (const k of _nullishCoalesce(clear, () => ( []))) {
+          if (k in set) throw new Error(`"${k}" is both given and cleared; do one or the other.`);
+          changes[k] = null;
+        }
+        if (!Object.keys(changes).length) throw new Error('Give at least one field to change, or a field in "clear".');
+        return result(await controller.updateShotLayer(layer, changes));
+      }
+    },
+    {
+      name: "move_shot_layer",
+      title: "Restack a shot layer",
+      description: "Moves a layer to another place in its shot's stack (0 = bottom; within a role, later layers draw over earlier ones). One undo step. Returns { shot, layer, layers }.",
+      inputSchema: { type: "object", properties: { layer: LAYER, index: { type: "integer", minimum: 0, description: "Its new place in the shot, 0 = bottom." } }, required: ["layer", "index"], additionalProperties: false },
+      annotations: { title: "Restack a shot layer", ...ctx.annotations.writeIdempotent },
+      handler: async ({ layer, index }) => result(await controller.moveShotLayer(layer, index))
+    },
+    {
+      name: "remove_shot_layer",
+      title: "Remove a shot layer",
+      description: "Removes a layer from its shot. Works without a provider. One undo step. Returns the shot's remaining layers.",
+      inputSchema: { type: "object", properties: { layer: LAYER }, required: ["layer"], additionalProperties: false },
+      annotations: { title: "Remove a shot layer", ...ctx.annotations.destructive },
+      handler: async ({ layer }) => result(await controller.removeShotLayer(layer))
+    },
+    {
+      name: "set_shot_transition",
+      title: "Set a shot's transition",
+      description: `Sets the transition into a shot: a provider effect with the use transition (search_effects with use "transition") blends the last frame of the shot before into this shot over ms. Not on the first shot (there is no shot before it). With no camera move in (set_shot_camera_move, role transition), the camera cuts and the transition does the move; with one, both play together. Checked first: an effect that is not a transition, an unknown preset or values outside its controls are refused. One undo step. Returns { shot, layers, transition: { effect, ms, values, start, end }, notes }.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          shot: { ...SHOT2, description: "A shot id from get_animation (not the first shot)." },
+          effect: { ...ctx.effectIdSchema(["transition"]), description: "A transition effect id from search_effects (use transition)." },
+          ms: { type: "number", exclusiveMinimum: 0, maximum: 6e4, description: `How long it takes, ms (default ${_chunkJAOSL334cjs.EFFECT_TRANSITION_MS}).` },
+          preset: { type: "string", minLength: 1, description: "A preset of the transition by name, from describe_effect." },
+          values: ctx.valuesSchema("Control values over the transition's defaults (and the preset's)")
+        },
+        required: ["shot", "effect"],
+        additionalProperties: false
+      },
+      annotations: { title: "Set a shot's transition", ...ctx.annotations.writeIdempotent },
+      handler: async ({ shot, effect, ms: ms2, preset: preset2, values }) => {
+        ctx.requireProvider();
+        return result(await controller.setShotTransition(shot, { effect, ...ms2 !== void 0 ? { ms: ms2 } : {}, ...preset2 !== void 0 ? { preset: preset2 } : {}, ...values !== void 0 ? { values } : {} }));
+      }
+    },
+    {
+      name: "clear_shot_transition",
+      title: "Clear a shot's transition",
+      description: "Removes the transition into a shot, so it cuts (or the camera eases) from the shot before. Works without a provider. One undo step. Returns { shot, layers, transition: null }.",
+      inputSchema: { type: "object", properties: { shot: SHOT2 }, required: ["shot"], additionalProperties: false },
+      annotations: { title: "Clear a shot's transition", ...ctx.annotations.destructive },
+      handler: async ({ shot }) => result(controller.clearShotTransition(shot))
+    }
+  ];
+}
+
 // src/animation-editor/effect-tools.ts
 var info = (e) => ({ id: e.instance, effect: e.effect, ...e.name ? { name: e.name } : {}, ...e.provider ? { provider: e.provider } : {}, role: e.kind === "vector" ? "vector picture" : "motion", enabled: true, values: e.values, targets: e.targets, shots: e.shots });
 function createAnimationEffectsToolProvider(controller, options = {}) {
@@ -6241,7 +7052,7 @@ function createAnimationEffectsToolProvider(controller, options = {}) {
     if (!r.ok) throw new Error(r.error);
     return { target, effect: info(r.effect), effects: controller.appliedEffects().filter((e) => e.targets.includes(target)).map(info), ...r.notes.length ? { notes: r.notes } : {} };
   };
-  return withAnimationPlayback(_chunk2K5TELHVcjs.createEffectToolProvider.call(void 0, {
+  return withAnimationPlayback(_chunkJAOSL334cjs.createEffectToolProvider.call(void 0, {
     id: _nullishCoalesce(options.id, () => ( "animation-effects")),
     namespace: options.namespace,
     title: "Animation effects",
@@ -6275,6 +7086,7 @@ function createAnimationEffectsToolProvider(controller, options = {}) {
     subscribe: (notify) => controller.subscribe(() => notify()),
     extraTools: (ctx) => [
       ...animationCameraMoveTools(controller, ctx),
+      ...animationShotLayerTools(controller, ctx),
       {
         name: "add_vector_effect",
         title: "Add a vector effect",
@@ -6318,8 +7130,8 @@ function createAnimationEditorDocument(controller) {
     kind: "animation",
     get: () => controller.getScene(),
     load: (document, { history }) => {
-      const result = controller.load(document, { clearHistory: history === "reset" });
-      if (!result.ok) throw new Error(result.error);
+      const result2 = controller.load(document, { clearHistory: history === "reset" });
+      if (!result2.ok) throw new Error(result2.error);
     },
     subscribe: (listener) => {
       let scene = controller.getScene();
@@ -6512,4 +7324,23 @@ function createAnimationEditorDocument(controller) {
 
 
 
-exports.ANIMATION_EDITOR_AGENT_INSTRUCTIONS = ANIMATION_EDITOR_AGENT_INSTRUCTIONS; exports.AnimationEditorController = AnimationEditorController; exports.FLAIR_EASES = FLAIR_EASES; exports.FLAIR_EXPORT_VERSION = FLAIR_EXPORT_VERSION; exports.MOTION_ADDITIVE_PROPERTIES = MOTION_ADDITIVE_PROPERTIES; exports.MOTION_BLENDS = MOTION_BLENDS; exports.MOTION_CAMERA_MS = MOTION_CAMERA_MS; exports.MOTION_CASCADES = MOTION_CASCADES; exports.MOTION_CLIP_TARGET = MOTION_CLIP_TARGET; exports.MOTION_COMMAND_FIELDS = MOTION_COMMAND_FIELDS; exports.MOTION_COMMAND_SCHEMA = MOTION_COMMAND_SCHEMA; exports.MOTION_COMMAND_TYPES = MOTION_COMMAND_TYPES; exports.MOTION_COMMAND_TYPE_SCHEMAS = MOTION_COMMAND_TYPE_SCHEMAS; exports.MOTION_DEFAULT_DURATIONS = MOTION_DEFAULT_DURATIONS; exports.MOTION_DEFAULT_HOLD = MOTION_DEFAULT_HOLD; exports.MOTION_DIRECTIONS = MOTION_DIRECTIONS; exports.MOTION_DRAW_EFFECT_ID = MOTION_DRAW_EFFECT_ID; exports.MOTION_DRAW_MS_PER_UNIT = MOTION_DRAW_MS_PER_UNIT; exports.MOTION_DRAW_RANGE = MOTION_DRAW_RANGE; exports.MOTION_DRIVEN_PROPERTIES = MOTION_DRIVEN_PROPERTIES; exports.MOTION_EASE_CHOICES = MOTION_EASE_CHOICES; exports.MOTION_EASE_IN_OUT = MOTION_EASE_IN_OUT; exports.MOTION_EASE_OUT = MOTION_EASE_OUT; exports.MOTION_EDIT_OPS = MOTION_EDIT_OPS; exports.MOTION_ENTER_STYLES = MOTION_ENTER_STYLES; exports.MOTION_EXIT_STYLES = MOTION_EXIT_STYLES; exports.MOTION_IRIS_SHAPES = MOTION_IRIS_SHAPES; exports.MOTION_ISSUE_CODES = _chunkERJA5CGTcjs.MOTION_ISSUE_CODES; exports.MOTION_MAX_TAKE_MS = MOTION_MAX_TAKE_MS; exports.MOTION_MIN_CHANGE_MS = MOTION_MIN_CHANGE_MS; exports.MOTION_RECORD_GESTURE_MODES = MOTION_RECORD_GESTURE_MODES; exports.MOTION_REPEAT_MODES = MOTION_REPEAT_MODES; exports.MOTION_SPEED_RANGE = MOTION_SPEED_RANGE; exports.MOTION_SPLIT_ORIENTATIONS = MOTION_SPLIT_ORIENTATIONS; exports.MOTION_TEXT_STAGGER = MOTION_TEXT_STAGGER; exports.MOTION_TEXT_UNITS = MOTION_TEXT_UNITS; exports.MOTION_TRIGGERS = MOTION_TRIGGERS; exports.MotionSceneFormatError = MotionSceneFormatError; exports.activeSegment = activeSegment; exports.animationCameraMoveTools = animationCameraMoveTools; exports.applyMotionControlValues = applyMotionControlValues; exports.applyMotionDrivers = applyMotionDrivers; exports.applyMotionEdits = applyMotionEdits; exports.checkMotionCameraMoves = checkMotionCameraMoves; exports.checkMotionScene = checkMotionScene; exports.clipsShapeProblems = clipsShapeProblems; exports.commandShapeProblems = commandShapeProblems; exports.compileMotionScene = compileMotionScene; exports.createAnimationEditorDocument = createAnimationEditorDocument; exports.createAnimationEditorToolProvider = createAnimationEditorToolProvider; exports.createAnimationEffectsToolProvider = createAnimationEffectsToolProvider; exports.createMotionScene = createMotionScene; exports.defaultMotionCommand = defaultMotionCommand; exports.describeMotionElements = describeMotionElements; exports.describeMotionShots = describeMotionShots; exports.driversShapeProblems = driversShapeProblems; exports.duplicateMotionCommandEdit = duplicateMotionCommandEdit; exports.effectsPlayCamera = effectsPlayCamera; exports.fitMotionRect = fitMotionRect; exports.fitMotionScene = fitMotionScene; exports.fitMotionSceneEdits = fitMotionSceneEdits; exports.flairAtLeast = flairAtLeast; exports.flairCurveFor = flairCurveFor; exports.flairEaseFor = flairEaseFor; exports.formatMotionDrivers = formatMotionDrivers; exports.formatMotionNarration = formatMotionNarration; exports.freshShotId = freshShotId; exports.fromFlairSvgMotion = fromFlairSvgMotion; exports.fromFlairVectorEffect = fromFlairVectorEffect; exports.fromPptxAnimation = fromPptxAnimation; exports.highlightMotionSvg = highlightMotionSvg; exports.indexMotionNodes = indexMotionNodes; exports.interpolateMotionValue = interpolateMotionValue; exports.isMotionCommand = isMotionCommand; exports.isMotionShot = isMotionShot; exports.matchMotionNodes = matchMotionNodes; exports.motionAddTrackKey = motionAddTrackKey; exports.motionArtworkSvg = motionArtworkSvg; exports.motionBeatAt = motionBeatAt; exports.motionBeatTime = motionBeatTime; exports.motionBlurTimes = motionBlurTimes; exports.motionCameraBox = motionCameraBox; exports.motionCameraFramed = motionCameraFramed; exports.motionCameraMoves = motionCameraMoves; exports.motionCameraStage = motionCameraStage; exports.motionCameraTransform = motionCameraTransform; exports.motionCameraViewAt = motionCameraViewAt; exports.motionCameraWindows = motionCameraWindows; exports.motionCascade = motionCascade; exports.motionClientToDocument = motionClientToDocument; exports.motionClipAttrs = motionClipAttrs; exports.motionClipLayout = motionClipLayout; exports.motionCommandDuration = motionCommandDuration; exports.motionCommandFields = motionCommandFields; exports.motionCommandRepeat = motionCommandRepeat; exports.motionCommandRows = motionCommandRows; exports.motionCommandSlots = motionCommandSlots; exports.motionCommandSummary = motionCommandSummary; exports.motionCommandsFromEffect = motionCommandsFromEffect; exports.motionContactSheetSvg = motionContactSheetSvg; exports.motionCueChoices = motionCueChoices; exports.motionCueFromKey = motionCueFromKey; exports.motionCueKey = motionCueKey; exports.motionCueTime = motionCueTime; exports.motionCycleDuration = motionCycleDuration; exports.motionDrivenNodes = motionDrivenNodes; exports.motionDriverSources = motionDriverSources; exports.motionEaseKey = motionEaseKey; exports.motionEasingCurve = motionEasingCurve; exports.motionEasingGuides = motionEasingGuides; exports.motionEasingPath = motionEasingPath; exports.motionFieldEdit = motionFieldEdit; exports.motionFieldLabel = motionFieldLabel; exports.motionFlairPrimitive = motionFlairPrimitive; exports.motionFollowRoute = motionFollowRoute; exports.motionFrameAt = motionFrameAt; exports.motionFrameToSvg = motionFrameToSvg; exports.motionGhosts = motionGhosts; exports.motionIssue = _chunkERJA5CGTcjs.motionIssue; exports.motionIssueKey = _chunkERJA5CGTcjs.motionIssueKey; exports.motionIssueLine = _chunkERJA5CGTcjs.motionIssueLine; exports.motionMovingIds = motionMovingIds; exports.motionNodeAtElement = motionNodeAtElement; exports.motionNodeClips = motionNodeClips; exports.motionNodeOffset = motionNodeOffset; exports.motionNodePose = motionNodePose; exports.motionPartsFromVectorEffect = motionPartsFromVectorEffect; exports.motionPath = motionPath; exports.motionPathLength = motionPathLength; exports.motionPathsSvg = motionPathsSvg; exports.motionPropertyValue = motionPropertyValue; exports.motionRestValue = motionRestValue; exports.motionRevealClip = motionRevealClip; exports.motionRevealPadding = motionRevealPadding; exports.motionRulerTicks = motionRulerTicks; exports.motionSceneEffects = motionSceneEffects; exports.motionSceneShapeProblems = motionSceneShapeProblems; exports.motionSceneToJson = motionSceneToJson; exports.motionShotAt = motionShotAt; exports.motionShotCameraMove = motionShotCameraMove; exports.motionShotCueTime = motionShotCueTime; exports.motionShotTimeScale = motionShotTimeScale; exports.motionStageSvg = motionStageSvg; exports.motionTakeProblems = motionTakeProblems; exports.motionTakeShot = motionTakeShot; exports.motionTextLayout = motionTextLayout; exports.motionTextUnits = motionTextUnits; exports.motionTrackKey = motionTrackKey; exports.namedWithSuggestion = _chunkERJA5CGTcjs.namedWithSuggestion; exports.nextMotionEffectInstance = nextMotionEffectInstance; exports.parseMotionDrivers = parseMotionDrivers; exports.parseMotionFieldInput = parseMotionFieldInput; exports.parseMotionNarration = parseMotionNarration; exports.parseMotionScene = parseMotionScene; exports.planAnimationToolPlayback = planAnimationToolPlayback; exports.resolveMotionCamera = resolveMotionCamera; exports.resolveMotionEditRefs = resolveMotionEditRefs; exports.segmentProgress = segmentProgress; exports.segmentValue = segmentValue; exports.shotShapeProblems = shotShapeProblems; exports.simplifyTimedSamples = simplifyTimedSamples; exports.smoothMotionLegs = smoothMotionLegs; exports.smoothMotionTimes = smoothMotionTimes; exports.suggestName = _chunkERJA5CGTcjs.suggestName; exports.toFlairEffectDocument = toFlairEffectDocument; exports.toFlairSvgMotion = toFlairSvgMotion; exports.toFlairVectorEffect = toFlairVectorEffect; exports.toLottie = toLottie; exports.trackValue = trackValue; exports.withAnimationPlayback = withAnimationPlayback; exports.withCameraViewEffects = withCameraViewEffects; exports.withMotionLayers = withMotionLayers; exports.withViewBox = withViewBox; exports.withoutMotionEffect = withoutMotionEffect;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ANIMATION_EDITOR_AGENT_INSTRUCTIONS = ANIMATION_EDITOR_AGENT_INSTRUCTIONS; exports.AnimationEditorController = AnimationEditorController; exports.FLAIR_EASES = FLAIR_EASES; exports.FLAIR_EXPORT_VERSION = FLAIR_EXPORT_VERSION; exports.MOTION_ADDITIVE_PROPERTIES = MOTION_ADDITIVE_PROPERTIES; exports.MOTION_BLENDS = MOTION_BLENDS; exports.MOTION_CAMERA_MS = MOTION_CAMERA_MS; exports.MOTION_CASCADES = MOTION_CASCADES; exports.MOTION_CLIP_TARGET = MOTION_CLIP_TARGET; exports.MOTION_COMMAND_FIELDS = MOTION_COMMAND_FIELDS; exports.MOTION_COMMAND_SCHEMA = MOTION_COMMAND_SCHEMA; exports.MOTION_COMMAND_TYPES = MOTION_COMMAND_TYPES; exports.MOTION_COMMAND_TYPE_SCHEMAS = MOTION_COMMAND_TYPE_SCHEMAS; exports.MOTION_DEFAULT_DURATIONS = MOTION_DEFAULT_DURATIONS; exports.MOTION_DEFAULT_HOLD = MOTION_DEFAULT_HOLD; exports.MOTION_DIRECTIONS = MOTION_DIRECTIONS; exports.MOTION_DRAW_EFFECT_ID = MOTION_DRAW_EFFECT_ID; exports.MOTION_DRAW_MS_PER_UNIT = MOTION_DRAW_MS_PER_UNIT; exports.MOTION_DRAW_RANGE = MOTION_DRAW_RANGE; exports.MOTION_DRIVEN_PROPERTIES = MOTION_DRIVEN_PROPERTIES; exports.MOTION_EASE_CHOICES = MOTION_EASE_CHOICES; exports.MOTION_EASE_IN_OUT = MOTION_EASE_IN_OUT; exports.MOTION_EASE_OUT = MOTION_EASE_OUT; exports.MOTION_EDIT_OPS = MOTION_EDIT_OPS; exports.MOTION_ENTER_STYLES = MOTION_ENTER_STYLES; exports.MOTION_EXIT_STYLES = MOTION_EXIT_STYLES; exports.MOTION_IRIS_SHAPES = MOTION_IRIS_SHAPES; exports.MOTION_ISSUE_CODES = _chunkDGWOGQJ5cjs.MOTION_ISSUE_CODES; exports.MOTION_MAX_TAKE_MS = MOTION_MAX_TAKE_MS; exports.MOTION_MIN_CHANGE_MS = MOTION_MIN_CHANGE_MS; exports.MOTION_RECORD_GESTURE_MODES = MOTION_RECORD_GESTURE_MODES; exports.MOTION_REPEAT_MODES = MOTION_REPEAT_MODES; exports.MOTION_SPEED_RANGE = MOTION_SPEED_RANGE; exports.MOTION_SPLIT_ORIENTATIONS = MOTION_SPLIT_ORIENTATIONS; exports.MOTION_TEXT_STAGGER = MOTION_TEXT_STAGGER; exports.MOTION_TEXT_UNITS = MOTION_TEXT_UNITS; exports.MOTION_TRIGGERS = MOTION_TRIGGERS; exports.MotionLayersEngine = MotionLayersEngine; exports.MotionSceneFormatError = MotionSceneFormatError; exports.activeSegment = activeSegment; exports.animationCameraMoveTools = animationCameraMoveTools; exports.animationShotLayerTools = animationShotLayerTools; exports.applyMotionControlValues = applyMotionControlValues; exports.applyMotionDrivers = applyMotionDrivers; exports.applyMotionEdits = applyMotionEdits; exports.browserMotionLayerHost = browserMotionLayerHost; exports.checkMotionCameraMoves = checkMotionCameraMoves; exports.checkMotionScene = checkMotionScene; exports.checkMotionShotLayers = checkMotionShotLayers; exports.clipsShapeProblems = clipsShapeProblems; exports.commandShapeProblems = commandShapeProblems; exports.compileMotionScene = compileMotionScene; exports.createAnimationEditorDocument = createAnimationEditorDocument; exports.createAnimationEditorToolProvider = createAnimationEditorToolProvider; exports.createAnimationEffectsToolProvider = createAnimationEffectsToolProvider; exports.createMotionScene = createMotionScene; exports.defaultMotionCommand = defaultMotionCommand; exports.describeMotionElements = describeMotionElements; exports.describeMotionShots = describeMotionShots; exports.driversShapeProblems = driversShapeProblems; exports.duplicateMotionCommandEdit = duplicateMotionCommandEdit; exports.effectsPlayCamera = effectsPlayCamera; exports.findMotionShotLayer = findMotionShotLayer; exports.fitMotionRect = fitMotionRect; exports.fitMotionScene = fitMotionScene; exports.fitMotionSceneEdits = fitMotionSceneEdits; exports.flairAtLeast = flairAtLeast; exports.flairCurveFor = flairCurveFor; exports.flairEaseFor = flairEaseFor; exports.formatMotionDrivers = formatMotionDrivers; exports.formatMotionNarration = formatMotionNarration; exports.freshMotionLayerId = freshMotionLayerId; exports.freshShotId = freshShotId; exports.fromFlairSvgMotion = fromFlairSvgMotion; exports.fromFlairVectorEffect = fromFlairVectorEffect; exports.fromPptxAnimation = fromPptxAnimation; exports.highlightMotionSvg = highlightMotionSvg; exports.indexMotionNodes = indexMotionNodes; exports.interpolateMotionValue = interpolateMotionValue; exports.isMotionCommand = isMotionCommand; exports.isMotionShot = isMotionShot; exports.matchMotionNodes = matchMotionNodes; exports.motionAddTrackKey = motionAddTrackKey; exports.motionArtworkSvg = motionArtworkSvg; exports.motionBeatAt = motionBeatAt; exports.motionBeatTime = motionBeatTime; exports.motionBlurTimes = motionBlurTimes; exports.motionCameraBox = motionCameraBox; exports.motionCameraFramed = motionCameraFramed; exports.motionCameraMoves = motionCameraMoves; exports.motionCameraStage = motionCameraStage; exports.motionCameraTransform = motionCameraTransform; exports.motionCameraViewAt = motionCameraViewAt; exports.motionCameraWindows = motionCameraWindows; exports.motionCascade = motionCascade; exports.motionClientToDocument = motionClientToDocument; exports.motionClipAttrs = motionClipAttrs; exports.motionClipLayout = motionClipLayout; exports.motionCommandDuration = motionCommandDuration; exports.motionCommandFields = motionCommandFields; exports.motionCommandRepeat = motionCommandRepeat; exports.motionCommandRows = motionCommandRows; exports.motionCommandSlots = motionCommandSlots; exports.motionCommandSummary = motionCommandSummary; exports.motionCommandsFromEffect = motionCommandsFromEffect; exports.motionContactSheetSvg = motionContactSheetSvg; exports.motionCueChoices = motionCueChoices; exports.motionCueFromKey = motionCueFromKey; exports.motionCueKey = motionCueKey; exports.motionCueTime = motionCueTime; exports.motionCycleDuration = motionCycleDuration; exports.motionDrivenNodes = motionDrivenNodes; exports.motionDriverSources = motionDriverSources; exports.motionEaseKey = motionEaseKey; exports.motionEasingCurve = motionEasingCurve; exports.motionEasingGuides = motionEasingGuides; exports.motionEasingPath = motionEasingPath; exports.motionFieldEdit = motionFieldEdit; exports.motionFieldLabel = motionFieldLabel; exports.motionFlairPrimitive = motionFlairPrimitive; exports.motionFollowRoute = motionFollowRoute; exports.motionFrameAt = motionFrameAt; exports.motionFrameToSvg = motionFrameToSvg; exports.motionGhosts = motionGhosts; exports.motionIssue = _chunkDGWOGQJ5cjs.motionIssue; exports.motionIssueKey = _chunkDGWOGQJ5cjs.motionIssueKey; exports.motionIssueLine = _chunkDGWOGQJ5cjs.motionIssueLine; exports.motionLayerIds = motionLayerIds; exports.motionLayerSlot = motionLayerSlot; exports.motionLayerSpans = motionLayerSpans; exports.motionLayersAt = motionLayersAt; exports.motionMovingIds = motionMovingIds; exports.motionNodeAtElement = motionNodeAtElement; exports.motionNodeClips = motionNodeClips; exports.motionNodeOffset = motionNodeOffset; exports.motionNodePose = motionNodePose; exports.motionPartsFromVectorEffect = motionPartsFromVectorEffect; exports.motionPath = motionPath; exports.motionPathLength = motionPathLength; exports.motionPathsSvg = motionPathsSvg; exports.motionPropertyValue = motionPropertyValue; exports.motionRestValue = motionRestValue; exports.motionRevealClip = motionRevealClip; exports.motionRevealPadding = motionRevealPadding; exports.motionRulerTicks = motionRulerTicks; exports.motionSceneEffects = motionSceneEffects; exports.motionSceneHasLayers = motionSceneHasLayers; exports.motionSceneShapeProblems = motionSceneShapeProblems; exports.motionSceneToJson = motionSceneToJson; exports.motionShotAt = motionShotAt; exports.motionShotCameraMove = motionShotCameraMove; exports.motionShotCueTime = motionShotCueTime; exports.motionShotLayersInfo = motionShotLayersInfo; exports.motionShotTimeScale = motionShotTimeScale; exports.motionStageSvg = motionStageSvg; exports.motionTakeProblems = motionTakeProblems; exports.motionTakeShot = motionTakeShot; exports.motionTextLayout = motionTextLayout; exports.motionTextUnits = motionTextUnits; exports.motionTrackKey = motionTrackKey; exports.motionTransitionAt = motionTransitionAt; exports.motionTransitionSvg = motionTransitionSvg; exports.namedWithSuggestion = _chunkDGWOGQJ5cjs.namedWithSuggestion; exports.nextMotionEffectInstance = nextMotionEffectInstance; exports.parseMotionDrivers = parseMotionDrivers; exports.parseMotionFieldInput = parseMotionFieldInput; exports.parseMotionNarration = parseMotionNarration; exports.parseMotionScene = parseMotionScene; exports.planAnimationToolPlayback = planAnimationToolPlayback; exports.resolveMotionCamera = resolveMotionCamera; exports.resolveMotionEditRefs = resolveMotionEditRefs; exports.resolveMotionShotLayer = resolveMotionShotLayer; exports.resolveMotionShotTransition = resolveMotionShotTransition; exports.segmentProgress = segmentProgress; exports.segmentValue = segmentValue; exports.shotLayersShapeProblems = shotLayersShapeProblems; exports.shotShapeProblems = shotShapeProblems; exports.simplifyTimedSamples = simplifyTimedSamples; exports.smoothMotionLegs = smoothMotionLegs; exports.smoothMotionTimes = smoothMotionTimes; exports.suggestName = _chunkDGWOGQJ5cjs.suggestName; exports.svgDataUrl = svgDataUrl; exports.toFlairEffectDocument = toFlairEffectDocument; exports.toFlairSvgMotion = toFlairSvgMotion; exports.toFlairVectorEffect = toFlairVectorEffect; exports.toLottie = toLottie; exports.trackValue = trackValue; exports.withAnimationPlayback = withAnimationPlayback; exports.withCameraViewEffects = withCameraViewEffects; exports.withMotionLayers = withMotionLayers; exports.withMotionShotLayers = withMotionShotLayers; exports.withViewBox = withViewBox; exports.withoutMotionEffect = withoutMotionEffect;