@pixerate/editor 0.53.0 → 0.55.0

package/dist/animation-editor/index.cjs

@@ -0,0 +1,2221 @@
+"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 _chunkXCXQDPIDcjs = require('../chunk-XCXQDPID.cjs');
+
+
+
+
+
+var _chunkO2UH7LZEcjs = require('../chunk-O2UH7LZE.cjs');
+
+
+var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
+
+
+var _chunkO4ONBPZWcjs = require('../chunk-O4ONBPZW.cjs');
+
+
+var _chunkMR3Z4OQIcjs = require('../chunk-MR3Z4OQI.cjs');
+
+
+
+
+var _chunkA6PHCAGXcjs = require('../chunk-A6PHCAGX.cjs');
+
+
+
+
+var _chunkXZ4L3R4Kcjs = require('../chunk-XZ4L3R4K.cjs');
+
+// src/animation-editor/types.ts
+var MOTION_COMMAND_TYPES = [
+  "enter",
+  "exit",
+  "draw",
+  "move",
+  "rotate",
+  "scale",
+  "fade",
+  "style",
+  "morph",
+  "follow",
+  "pulse",
+  "shake",
+  "effect",
+  "wait"
+];
+var MOTION_ENTER_STYLES = ["fade", "pop", "grow", "slide", "draw"];
+var MOTION_EXIT_STYLES = ["fade", "shrink", "slide", "undraw"];
+var MOTION_DIRECTIONS = ["up", "down", "left", "right"];
+var MOTION_DEFAULT_DURATIONS = {
+  enter: 600,
+  exit: 450,
+  move: 700,
+  rotate: 700,
+  scale: 500,
+  fade: 400,
+  style: 500,
+  morph: 900,
+  follow: 1400,
+  pulse: 600,
+  shake: 500,
+  effect: 900
+};
+var MOTION_DEFAULT_HOLD = 600;
+var MOTION_CAMERA_MS = 1e3;
+var MOTION_DRAW_MS_PER_UNIT = 1.5;
+var MOTION_DRAW_RANGE = [500, 2500];
+
+// src/animation-editor/issues.ts
+var MOTION_ISSUE_CODES = {
+  "no-shots": { severity: "note", wording: "The scene has no shots yet." },
+  "duplicate-shot-id": { severity: "error", wording: "Two shots share an id." },
+  "unknown-target": { severity: "error", wording: "A command names a node the artwork does not have." },
+  "unknown-path": { severity: "error", wording: "A follow command names a path the artwork does not have." },
+  "not-a-path": { severity: "error", wording: "A follow path must be a path node, not a group." },
+  "unknown-shape": { severity: "error", wording: "A morph names a shape the artwork does not have." },
+  "unknown-effect": { severity: "error", wording: "An effect command names an effect the node does not have." },
+  "unknown-effect-param": { severity: "error", wording: "An effect command names a parameter that is not a number of that effect." },
+  "unknown-frame": { severity: "error", wording: "A camera frames a node the artwork does not have." },
+  "invalid-camera": { severity: "error", wording: "A camera rectangle has no area." },
+  "invalid-color": { severity: "error", wording: "A colour cannot be read." },
+  "paint-not-color": { severity: "warning", wording: "A style command recolours a gradient or empty paint, which only switches at the end." },
+  "overlap": { severity: "warning", wording: "Two commands change the same property of a node at the same time; the later one wins." },
+  "enter-visible": { severity: "warning", wording: "A node enters while it is already showing, so it blinks out first." },
+  "exit-hidden": { severity: "warning", wording: "A node exits or animates while it is hidden." },
+  "out-of-frame": { severity: "warning", wording: "A node a command animates ends up outside the camera." },
+  "too-fast": { severity: "warning", wording: "A change is too quick to follow." },
+  "scene-too-long": { severity: "warning", wording: "The scene runs past its target length." },
+  "scene-too-short": { severity: "warning", wording: "The scene ends before its target length." },
+  "unknown-control-color": { severity: "warning", wording: "A control stands for a colour the scene never uses." },
+  "empty-shot": { severity: "note", wording: "A shot neither moves the camera nor runs a command." },
+  "camera-aspect": { severity: "note", wording: "A camera rectangle has a different shape from the artwork, so it is letterboxed." }
+};
+function motionIssue(code, message, extra = {}) {
+  return { code, severity: MOTION_ISSUE_CODES[code].severity, message, ...extra };
+}
+function motionIssueKey(issue) {
+  if (_optionalChain([issue, 'access', _2 => _2.ids, 'optionalAccess', _3 => _3.length])) return `${issue.code}:${[...issue.ids].sort().join(",")}`;
+  return `${issue.code}@${_nullishCoalesce(issue.shot, () => ( ""))}#${_nullishCoalesce(issue.command, () => ( ""))}`;
+}
+function motionIssueLine(issue) {
+  const where = issue.shot !== void 0 ? `Shot "${issue.shot}"${issue.command !== void 0 ? `, command ${issue.command + 1}` : ""}: ` : "";
+  return `${where}${issue.message}`;
+}
+function editDistance(a, b) {
+  const d = Array.from({ length: a.length + 1 }, (_, i) => [i, ...Array(b.length).fill(0)]);
+  for (let j = 1; j <= b.length; j++) d[0][j] = j;
+  for (let i = 1; i <= a.length; i++) {
+    for (let j = 1; j <= b.length; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
+    }
+  }
+  return d[a.length][b.length];
+}
+function suggestName(word, candidates) {
+  const w = word.toLowerCase();
+  let best;
+  let bestDistance = Infinity;
+  for (const c of candidates) {
+    const distance = editDistance(w, c.toLowerCase());
+    if (distance < bestDistance) {
+      best = c;
+      bestDistance = distance;
+    }
+  }
+  return best !== void 0 && bestDistance <= Math.max(1, Math.floor(word.length / 3)) ? best : void 0;
+}
+function namedWithSuggestion(word, candidates) {
+  const s = suggestName(word, candidates);
+  return s !== void 0 && s !== word ? `"${word}" (did you mean "${s}"?)` : `"${word}"`;
+}
+
+// src/animation-editor/parse.ts
+var MotionSceneFormatError = class extends Error {
+  
+  constructor(problems) {
+    super(`The scene is not well formed:
+${problems.map((p) => `- ${p}`).join("\n")}`);
+    this.name = "MotionSceneFormatError";
+    this.problems = problems;
+  }
+};
+var SCENE_KEYS = ["version", "name", "description", "artwork", "shots", "loop", "fps", "target", "controls", "presets"];
+var SHOT_KEYS = ["id", "label", "camera", "run", "hold"];
+var CAMERA_KEYS = ["x", "y", "width", "height", "frame", "padding", "ease", "ms"];
+var BASE_KEYS = ["type", "targets", "duration", "delay", "stagger", "with", "ease", "note"];
+var COMMAND_KEYS = {
+  enter: [...BASE_KEYS, "style", "direction", "distance"],
+  exit: [...BASE_KEYS, "style", "direction", "distance"],
+  draw: [...BASE_KEYS, "from", "to"],
+  move: [...BASE_KEYS, "by", "to"],
+  rotate: [...BASE_KEYS, "by", "to"],
+  scale: [...BASE_KEYS, "to"],
+  fade: [...BASE_KEYS, "to"],
+  style: [...BASE_KEYS, "fill", "stroke", "strokeWidth"],
+  morph: [...BASE_KEYS, "into"],
+  follow: [...BASE_KEYS, "path", "rotate", "from", "to"],
+  pulse: [...BASE_KEYS, "amount", "count"],
+  shake: [...BASE_KEYS, "amount", "count"],
+  effect: [...BASE_KEYS, "effect", "param", "to"],
+  wait: ["type", "duration", "with", "note"]
+};
+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 ${namedWithSuggestion(key, known)}.`);
+}
+function commandShapeProblems(command2, where) {
+  const problems = [];
+  if (!isObject(command2)) return [`${where} must be an object.`];
+  const type = command2.type;
+  if (typeof type !== "string" || !MOTION_COMMAND_TYPES.includes(type)) {
+    return [`${where}: unknown type ${typeof type === "string" ? namedWithSuggestion(type, MOTION_COMMAND_TYPES) : String(type)}; use one of ${MOTION_COMMAND_TYPES.join(", ")}.`];
+  }
+  unknownKeys(command2, COMMAND_KEYS[type], `${where} (${type})`, problems);
+  const p = (msg) => problems.push(`${where} (${type}): ${msg}`);
+  const nonNegative = (key) => {
+    if (command2[key] !== void 0 && !(isNum(command2[key]) && command2[key] >= 0)) p(`"${key}" must be a number of milliseconds \u2265 0.`);
+  };
+  const fraction = (key) => {
+    if (command2[key] !== void 0 && !(isNum(command2[key]) && command2[key] >= 0 && command2[key] <= 1)) p(`"${key}" must be a fraction from 0 to 1.`);
+  };
+  const optionalNumber = (key) => {
+    if (command2[key] !== void 0 && !isNum(command2[key])) p(`"${key}" must be a number.`);
+  };
+  if (command2.with !== void 0 && command2.with !== "after" && command2.with !== "previous") p(`"with" must be "after" or "previous".`);
+  if (command2.note !== void 0 && typeof command2.note !== "string") p(`"note" must be a string.`);
+  if (type === "wait") {
+    if (!isNum(command2.duration) || command2.duration < 0) p(`"duration" must be a number of milliseconds \u2265 0.`);
+    return problems;
+  }
+  if (!Array.isArray(command2.targets) || command2.targets.length === 0 || !command2.targets.every((t) => typeof t === "string" && t.length > 0)) p(`"targets" must be a non-empty list of node ids.`);
+  nonNegative("duration");
+  nonNegative("delay");
+  nonNegative("stagger");
+  if (command2.ease !== void 0 && !_chunkXZ4L3R4Kcjs.isAnimationEasing.call(void 0, command2.ease)) p(`"ease" is not an easing; use a preset such as "ease-in-out" or { "type": "cubic-bezier", \u2026 }.`);
+  switch (type) {
+    case "enter":
+    case "exit": {
+      const styles = type === "enter" ? MOTION_ENTER_STYLES : MOTION_EXIT_STYLES;
+      if (command2.style !== void 0 && !(typeof command2.style === "string" && styles.includes(command2.style)))
+        p(`"style" must be one of ${styles.join(", ")}${typeof command2.style === "string" ? ` (got ${namedWithSuggestion(command2.style, styles)})` : ""}.`);
+      if (command2.direction !== void 0 && !MOTION_DIRECTIONS.includes(command2.direction)) p(`"direction" must be one of ${MOTION_DIRECTIONS.join(", ")}.`);
+      optionalNumber("distance");
+      break;
+    }
+    case "draw":
+      fraction("from");
+      fraction("to");
+      break;
+    case "move":
+      if (command2.by === void 0 && command2.to === void 0) p(`give "by" (an offset) or "to" (a point).`);
+      if (command2.by !== void 0 && command2.to !== void 0) p(`give "by" or "to", not both.`);
+      if (command2.by !== void 0 && !isPoint(command2.by)) p(`"by" must be { "x": number, "y": number }.`);
+      if (command2.to !== void 0 && !isPoint(command2.to)) p(`"to" must be { "x": number, "y": number }.`);
+      break;
+    case "rotate":
+      if (command2.by === void 0 && command2.to === void 0) p(`give "by" or "to" (degrees).`);
+      if (command2.by !== void 0 && command2.to !== void 0) p(`give "by" or "to", not both.`);
+      optionalNumber("by");
+      optionalNumber("to");
+      break;
+    case "scale":
+      if (!(isNum(command2.to) || isPoint(command2.to))) p(`"to" must be a number or { "x": number, "y": number }.`);
+      break;
+    case "fade":
+      if (!(isNum(command2.to) && command2.to >= 0 && command2.to <= 1)) p(`"to" must be an opacity from 0 to 1.`);
+      break;
+    case "style":
+      if (command2.fill === void 0 && command2.stroke === void 0 && command2.strokeWidth === void 0) p(`give at least one of "fill", "stroke" or "strokeWidth".`);
+      if (command2.fill !== void 0 && typeof command2.fill !== "string") p(`"fill" must be a CSS colour.`);
+      if (command2.stroke !== void 0 && typeof command2.stroke !== "string") p(`"stroke" must be a CSS colour.`);
+      if (command2.strokeWidth !== void 0 && !(isNum(command2.strokeWidth) && command2.strokeWidth >= 0)) p(`"strokeWidth" must be a number \u2265 0.`);
+      break;
+    case "morph":
+      if (typeof command2.into !== "string" || !command2.into) p(`"into" must be the id of a node whose shape to take.`);
+      break;
+    case "follow":
+      if (typeof command2.path !== "string" || !command2.path) p(`"path" must be the id of a path node.`);
+      if (command2.rotate !== void 0 && typeof command2.rotate !== "boolean") p(`"rotate" must be true or false.`);
+      fraction("from");
+      fraction("to");
+      break;
+    case "pulse":
+    case "shake":
+      optionalNumber("amount");
+      if (command2.count !== void 0 && !(Number.isInteger(command2.count) && command2.count >= 1)) p(`"count" must be a whole number \u2265 1.`);
+      break;
+    case "effect":
+      if (typeof command2.effect !== "string" || !command2.effect) p(`"effect" must be the id of one of the node's effects.`);
+      if (typeof command2.param !== "string" || !command2.param) p(`"param" must name a numeric parameter of the effect.`);
+      if (!isNum(command2.to)) p(`"to" must be a number.`);
+      break;
+  }
+  return problems;
+}
+function shotShapeProblems(shot, where) {
+  if (!isObject(shot)) return [`${where} must be an object.`];
+  const problems = [];
+  unknownKeys(shot, SHOT_KEYS, where, problems);
+  if (typeof shot.id !== "string" || !/^[A-Za-z0-9_][\w.-]*$/.test(shot.id)) problems.push(`${where}: "id" must be letters, digits, "_", "-" or "." (e.g. "intro").`);
+  const name = typeof shot.id === "string" ? `Shot "${shot.id}"` : where;
+  if (shot.label !== void 0 && typeof shot.label !== "string") problems.push(`${name}: "label" must be a string.`);
+  if (shot.hold !== void 0 && !(isNum(shot.hold) && shot.hold >= 0)) problems.push(`${name}: "hold" must be a number of milliseconds \u2265 0.`);
+  if (shot.camera !== void 0) {
+    const c = shot.camera;
+    if (!isObject(c)) problems.push(`${name}: "camera" must be an object.`);
+    else {
+      unknownKeys(c, CAMERA_KEYS, `${name} camera`, problems);
+      const isRect = ["x", "y", "width", "height"].every((k) => isNum(c[k]));
+      if (typeof c.frame === "string") {
+        if (c.padding !== void 0 && !isNum(c.padding)) problems.push(`${name} camera: "padding" must be a number.`);
+      } else if (!isRect) problems.push(`${name} camera: give { x, y, width, height } or { frame: "<node id>" }.`);
+      if (c.ease !== void 0 && !_chunkXZ4L3R4Kcjs.isAnimationEasing.call(void 0, c.ease)) problems.push(`${name} camera: "ease" is not an easing.`);
+      if (c.ms !== void 0 && !(isNum(c.ms) && c.ms >= 0)) problems.push(`${name} camera: "ms" must be a number \u2265 0.`);
+    }
+  }
+  if (!Array.isArray(shot.run)) problems.push(`${name}: "run" must be a list of commands (it may be empty).`);
+  else shot.run.forEach((command2, i) => problems.push(...commandShapeProblems(command2, `${name}, command ${i + 1}`)));
+  return problems;
+}
+function motionSceneShapeProblems(input) {
+  if (!isObject(input)) return ["The scene must be an object."];
+  const problems = [];
+  unknownKeys(input, SCENE_KEYS, "Scene", problems);
+  if (input.version !== 1) problems.push('Scene: "version" must be 1.');
+  if (typeof input.name !== "string" || !input.name) problems.push('Scene: "name" must be a non-empty string.');
+  if (input.description !== void 0 && typeof input.description !== "string") problems.push('Scene: "description" must be a string.');
+  const art = input.artwork;
+  if (!isObject(art) || !isNum(art.width) || !isNum(art.height) || !(art.width > 0) || !(art.height > 0) || !Array.isArray(art.nodes))
+    problems.push('Scene: "artwork" must be a vector document { width, height, nodes }.');
+  if (input.loop !== void 0 && !["none", "loop", "ping-pong"].includes(input.loop)) problems.push('Scene: "loop" must be "none", "loop" or "ping-pong".');
+  if (input.fps !== void 0 && !(isNum(input.fps) && input.fps > 0 && input.fps <= 120)) problems.push('Scene: "fps" must be a number from 1 to 120.');
+  if (input.target !== void 0 && !(Array.isArray(input.target) && input.target.length === 2 && input.target.every(isNum) && input.target[0] <= input.target[1]))
+    problems.push('Scene: "target" must be [min, max] seconds.');
+  if (input.controls !== void 0) {
+    if (!Array.isArray(input.controls)) problems.push('Scene: "controls" must be a list.');
+    else
+      input.controls.forEach((c, i) => {
+        if (!isObject(c) || typeof c.name !== "string" || !/^[A-Za-z_]\w*$/.test(c.name) || c.type !== "color" || typeof c.default !== "string" || !/^#[0-9a-fA-F]{6}$/.test(c.default))
+          problems.push(`Scene: control ${i + 1} must be { name (an identifier), type: "color", default: "#rrggbb", label? }.`);
+      });
+  }
+  if (input.presets !== void 0 && !(Array.isArray(input.presets) && input.presets.every((p) => isObject(p) && typeof p.name === "string" && isObject(p.values))))
+    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}`)));
+  return problems;
+}
+function parseMotionScene(input) {
+  let value = input;
+  if (typeof input === "string") {
+    try {
+      value = JSON.parse(input);
+    } catch (error) {
+      throw new MotionSceneFormatError([`The scene is not valid JSON: ${error.message}`]);
+    }
+  }
+  const problems = motionSceneShapeProblems(value);
+  if (problems.length) throw new MotionSceneFormatError(problems);
+  return value;
+}
+function motionSceneToJson(scene, space = 2) {
+  return JSON.stringify(scene, null, space);
+}
+var isMotionShot = (shot) => shotShapeProblems(shot, "Shot").length === 0;
+var isMotionCommand = (command2) => commandShapeProblems(command2, "Command").length === 0;
+
+// src/animation-editor/compile.ts
+var indexCache = /* @__PURE__ */ new WeakMap();
+function indexMotionNodes(nodes) {
+  const hit = indexCache.get(nodes);
+  if (hit) return hit;
+  const out = /* @__PURE__ */ new Map();
+  const walk = (list, parentWorld, ancestors) => {
+    for (const node of list) {
+      const local = _chunkXCXQDPIDcjs.vectorNodeBounds.call(void 0, node);
+      const bounds = _chunkXCXQDPIDcjs.vectorNodeBounds.call(void 0, node, parentWorld);
+      const center = local ? { x: local.x + local.width / 2, y: local.y + local.height / 2 } : { x: 0, y: 0 };
+      if (!out.has(node.id)) out.set(node.id, { node, ancestors, parentWorld, center, bounds });
+      if (node.type === "group") walk(node.children, _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.nodeMatrix.call(void 0, node), parentWorld), [...ancestors, node.id]);
+    }
+  };
+  walk(nodes, _chunkXCXQDPIDcjs.IDENTITY_MATRIX, []);
+  indexCache.set(nodes, out);
+  return out;
+}
+var solid = (paint) => typeof paint === "string" && paint !== "none" ? paint : void 0;
+function firstPaint(node, key) {
+  if (node.type === "path") return solid(node[key]);
+  for (const p of _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node)) {
+    const s = solid(p[key]);
+    if (s) return s;
+  }
+  return void 0;
+}
+function motionRestValue(entry, property, artwork) {
+  const node = _optionalChain([entry, 'optionalAccess', _4 => _4.node]);
+  switch (property) {
+    case "opacity":
+      return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _5 => _5.opacity]), () => ( 1));
+    case "x":
+    case "y":
+    case "rotation":
+      return 0;
+    case "scaleX":
+    case "scaleY":
+    case "fillOpacity":
+    case "drawEnd":
+      return 1;
+    case "drawStart":
+      return 0;
+    case "follow":
+      return -1;
+    case "fill":
+    case "stroke":
+      return _nullishCoalesce((node && firstPaint(node, property)), () => ( "transparent"));
+    case "strokeWidth": {
+      const path = _optionalChain([node, 'optionalAccess', _6 => _6.type]) === "path" ? node : node ? _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node)[0] : void 0;
+      return _nullishCoalesce(_optionalChain([path, 'optionalAccess', _7 => _7.strokeWidth]), () => ( 1));
+    }
+    case "shape":
+      return _nullishCoalesce(_optionalChain([node, 'optionalAccess', _8 => _8.id]), () => ( ""));
+    case "camera":
+      return [0, 0, artwork.width, artwork.height];
+  }
+  const [, effectId, param] = property.split(":");
+  const effect = _optionalChain([node, 'optionalAccess', _9 => _9.effects, 'optionalAccess', _10 => _10.find, 'call', _11 => _11((e) => e.id === effectId)]);
+  const v = effect ? effect.params[param] : void 0;
+  return typeof v === "number" ? v : 0;
+}
+function interpolateMotionValue(from, to, u) {
+  if (typeof from === "number" && typeof to === "number") return from + (to - from) * u;
+  if (Array.isArray(from) && Array.isArray(to) && from.length === to.length) return from.map((f, i) => f + (to[i] - f) * u);
+  if (u <= 0) return from;
+  if (u >= 1) return to;
+  if (typeof from === "string" && typeof to === "string") {
+    const mixed = _chunkMR3Z4OQIcjs.mixColorsOklab.call(void 0, from, to, u);
+    if (mixed !== null) return mixed;
+  }
+  return u < 1 ? from : to;
+}
+function segmentProgress(segment, time) {
+  const span = segment.end - segment.start;
+  const u = span <= 0 ? 1 : Math.min(1, Math.max(0, (time - segment.start) / span));
+  return { u, eased: segment.wave ? u : _chunkXZ4L3R4Kcjs.evaluateEasing.call(void 0, segment.ease, u, span) };
+}
+function segmentValue(segment, time) {
+  const { u, eased } = segmentProgress(segment, time);
+  const v = interpolateMotionValue(segment.from, segment.to, eased);
+  if (!segment.wave || typeof v !== "number") return v;
+  const { kind, amount, count } = segment.wave;
+  if (kind === "pulse") return v * (1 + amount * Math.sin(Math.PI * u * count) ** 2);
+  return v + amount * Math.sin(2 * Math.PI * u * count) * (1 - u);
+}
+function activeSegment(track, time) {
+  if (!_optionalChain([track, 'optionalAccess', _12 => _12.length])) return void 0;
+  let found;
+  for (const s of track) if (s.start <= time && (!found || s.start >= found.start)) found = s;
+  return found;
+}
+function trackValue(track, time) {
+  if (!_optionalChain([track, 'optionalAccess', _13 => _13.length])) return void 0;
+  const s = activeSegment(track, time);
+  if (s) return segmentValue(s, time);
+  let first = track[0];
+  for (const t of track) if (t.start < first.start) first = t;
+  return first.from;
+}
+var motionTrackKey = (node, property) => `${node}\0${property}`;
+function fitMotionRect(rect, aspect) {
+  const cx = rect.x + rect.width / 2;
+  const cy = rect.y + rect.height / 2;
+  let { width, height } = rect;
+  if (width / height < aspect) width = height * aspect;
+  else height = width / aspect;
+  return { x: cx - width / 2, y: cy - height / 2, width, height };
+}
+function resolveMotionCamera(camera, scene) {
+  if ("frame" in camera && typeof camera.frame === "string") {
+    const entry = indexMotionNodes(scene.artwork.nodes).get(camera.frame);
+    if (!_optionalChain([entry, 'optionalAccess', _14 => _14.bounds])) return null;
+    const pad = _nullishCoalesce(camera.padding, () => ( 24));
+    const b = entry.bounds;
+    const rect = { x: b.x - pad, y: b.y - pad, width: Math.max(1, b.width + pad * 2), height: Math.max(1, b.height + pad * 2) };
+    return fitMotionRect(rect, scene.artwork.width / scene.artwork.height);
+  }
+  const r = camera;
+  return { x: r.x, y: r.y, width: r.width, height: r.height };
+}
+function motionPathLength(node, parentWorld = _chunkXCXQDPIDcjs.IDENTITY_MATRIX) {
+  let longest = 0;
+  const paths = node.type === "path" ? [node] : _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node);
+  for (const p of paths) {
+    try {
+      longest = Math.max(longest, _chunkO2UH7LZEcjs.bezierPathLength.call(void 0, _chunkXCXQDPIDcjs.vectorPathWorldBezier.call(void 0, p, parentWorld, { effects: false })));
+    } catch (e2) {
+    }
+  }
+  return longest;
+}
+function motionCommandDuration(command2, scene, target) {
+  if (command2.type === "wait") return command2.duration;
+  if (command2.duration !== void 0) return command2.duration;
+  if (command2.type === "draw" || command2.type === "enter" && command2.style === "draw" || command2.type === "exit" && command2.style === "undraw") {
+    const entry = target ? indexMotionNodes(scene.artwork.nodes).get(target) : void 0;
+    const length = entry ? motionPathLength(entry.node) : 0;
+    const ms = length * MOTION_DRAW_MS_PER_UNIT;
+    return Math.round(Math.min(MOTION_DRAW_RANGE[1], Math.max(MOTION_DRAW_RANGE[0], ms)));
+  }
+  return MOTION_DEFAULT_DURATIONS[command2.type];
+}
+var MOTION_EASE_OUT = { type: "cubic-bezier", x1: 1 / 3, y1: 1, x2: 2 / 3, y2: 1 };
+var MOTION_EASE_IN_OUT = { type: "cubic-bezier", x1: 0.65, y1: 0, x2: 0.35, y2: 1 };
+var DIRECTION = { up: { x: 0, y: -1 }, down: { x: 0, y: 1 }, left: { x: -1, y: 0 }, right: { x: 1, y: 0 } };
+var timelineCache = /* @__PURE__ */ new WeakMap();
+function compileMotionScene(scene) {
+  const hit = timelineCache.get(scene);
+  if (hit) return hit;
+  const nodes = indexMotionNodes(scene.artwork.nodes);
+  const artwork = scene.artwork;
+  const shots = [];
+  const commands = [];
+  const cameraMoves = [];
+  let t = 0;
+  scene.shots.forEach((shot, index) => {
+    const start = t;
+    let cursor = start;
+    if (shot.camera) {
+      const rect = resolveMotionCamera(shot.camera, scene);
+      if (rect && rect.width > 0 && rect.height > 0) {
+        const ms = index === 0 ? 0 : _nullishCoalesce(shot.camera.ms, () => ( MOTION_CAMERA_MS));
+        cameraMoves.push({ shot: shot.id, start, end: start + ms, to: rect, ease: _nullishCoalesce(shot.camera.ease, () => ( MOTION_EASE_IN_OUT)) });
+        cursor = start + ms;
+      }
+    }
+    const commandsStart = cursor;
+    let runEnd = cursor;
+    let prevStart = cursor;
+    shot.run.forEach((command2, i) => {
+      const base = command2.with === "previous" && i > 0 ? prevStart : runEnd;
+      const begin = base + (command2.type === "wait" ? 0 : _nullishCoalesce(command2.delay, () => ( 0)));
+      const targets = command2.type === "wait" ? [] : command2.targets;
+      const durations = command2.type === "wait" ? [command2.duration] : targets.map((id) => motionCommandDuration(command2, scene, id));
+      const stagger = command2.type === "wait" ? 0 : _nullishCoalesce(command2.stagger, () => ( 0));
+      const end2 = durations.reduce((m, d, k) => Math.max(m, begin + k * stagger + d), begin);
+      commands.push({ shot: shot.id, shotIndex: index, command: i, type: command2.type, start: begin, end: end2, duration: _nullishCoalesce(durations[0], () => ( 0)) });
+      prevStart = begin;
+      runEnd = Math.max(runEnd, end2);
+    });
+    const end = runEnd + (_nullishCoalesce(shot.hold, () => ( MOTION_DEFAULT_HOLD)));
+    shots.push({ id: shot.id, index, ...shot.label ? { label: shot.label } : {}, start, commandsStart, commandsEnd: runEnd, end });
+    t = end;
+  });
+  const tracks = /* @__PURE__ */ new Map();
+  const segments = [];
+  const valueAt = (node, property, time) => {
+    const v = trackValue(tracks.get(motionTrackKey(node, property)), time);
+    return _nullishCoalesce(v, () => ( motionRestValue(nodes.get(node), property, artwork)));
+  };
+  const push = (segment) => {
+    const key = motionTrackKey(segment.node, segment.property);
+    let track = tracks.get(key);
+    if (!track) tracks.set(key, track = []);
+    track.push(segment);
+    segments.push(segment);
+  };
+  const jobs = [];
+  let order = 0;
+  for (const move of cameraMoves) {
+    jobs.push({
+      start: move.start,
+      order: order++,
+      run: () => push({ node: "", property: "camera", start: move.start, end: move.end, from: valueAt("", "camera", move.start), to: [move.to.x, move.to.y, move.to.width, move.to.height], ease: move.ease, shot: move.shot, command: -1 })
+    });
+  }
+  for (const timing of commands) {
+    const shot = scene.shots[timing.shotIndex];
+    const command2 = shot.run[timing.command];
+    if (command2.type === "wait") continue;
+    command2.targets.forEach((target, k) => {
+      const entry = nodes.get(target);
+      if (!entry) return;
+      const start = timing.start + k * (_nullishCoalesce(command2.stagger, () => ( 0)));
+      const duration2 = motionCommandDuration(command2, scene, target);
+      jobs.push({ start, order: order++, run: () => compileCommand(command2, target, entry, start, duration2, timing) });
+    });
+  }
+  jobs.sort((a, b) => a.start - b.start || a.order - b.order).forEach((job) => job.run());
+  function compileCommand(command2, node, entry, start, duration2, timing) {
+    const end = start + duration2;
+    const where = { shot: timing.shot, command: timing.command };
+    const seg = (property, to, ease2, s = start, e = end, extra = {}) => push({ node, property, start: s, end: e, from: _nullishCoalesce(extra.from, () => ( valueAt(node, property, s))), to, ease: ease2, ...where, ...extra });
+    const rest = (p) => motionRestValue(entry, p, artwork);
+    const num = (p, time = start) => {
+      const v = valueAt(node, p, time);
+      return typeof v === "number" ? v : 0;
+    };
+    const ease = command2.ease;
+    switch (command2.type) {
+      case "enter": {
+        const style = _nullishCoalesce(command2.style, () => ( "fade"));
+        const opacity = rest("opacity");
+        if (style === "draw") {
+          seg("drawEnd", 1, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, start + duration2 * 0.75, { from: 0 });
+          seg("fillOpacity", 1, MOTION_EASE_OUT, start + duration2 * 0.6, end, { from: 0 });
+          break;
+        }
+        if (style === "pop") {
+          seg("opacity", opacity, MOTION_EASE_OUT, start, start + duration2 * 0.4, { from: 0 });
+          seg("scaleX", 1, _nullishCoalesce(ease, () => ( "ease-out-back")), start, end, { from: 0.5 });
+          seg("scaleY", 1, _nullishCoalesce(ease, () => ( "ease-out-back")), start, end, { from: 0.5 });
+        } else if (style === "grow") {
+          seg("opacity", opacity, MOTION_EASE_OUT, start, start + duration2 * 0.3, { from: 0 });
+          seg("scaleX", 1, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: 0 });
+          seg("scaleY", 1, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: 0 });
+        } else if (style === "slide") {
+          const dir = DIRECTION[_nullishCoalesce(command2.direction, () => ( "up"))];
+          const distance = _nullishCoalesce(command2.distance, () => ( 40));
+          const x = num("x");
+          const y = num("y");
+          seg("opacity", opacity, MOTION_EASE_OUT, start, end, { from: 0 });
+          seg("x", x, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: x - dir.x * distance });
+          seg("y", y, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: y - dir.y * distance });
+        } else seg("opacity", opacity, _nullishCoalesce(ease, () => ( MOTION_EASE_OUT)), start, end, { from: 0 });
+        break;
+      }
+      case "exit": {
+        const style = _nullishCoalesce(command2.style, () => ( "fade"));
+        if (style === "undraw") {
+          seg("fillOpacity", 0, "ease-in", start, start + duration2 * 0.4);
+          seg("drawEnd", 0, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        } else if (style === "shrink") {
+          seg("scaleX", 0, _nullishCoalesce(ease, () => ( "ease-in")));
+          seg("scaleY", 0, _nullishCoalesce(ease, () => ( "ease-in")));
+          seg("opacity", 0, "ease-in", start + duration2 * 0.6, end);
+        } else if (style === "slide") {
+          const dir = DIRECTION[_nullishCoalesce(command2.direction, () => ( "down"))];
+          const distance = _nullishCoalesce(command2.distance, () => ( 40));
+          seg("x", num("x") + dir.x * distance, _nullishCoalesce(ease, () => ( "ease-in")));
+          seg("y", num("y") + dir.y * distance, _nullishCoalesce(ease, () => ( "ease-in")));
+          seg("opacity", 0, _nullishCoalesce(ease, () => ( "ease-in")));
+        } else seg("opacity", 0, _nullishCoalesce(ease, () => ( "ease-in")));
+        break;
+      }
+      case "draw":
+        {
+          const drawn = tracks.has(motionTrackKey(node, "drawEnd"));
+          seg("drawEnd", _nullishCoalesce(command2.to, () => ( 1)), _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, end, command2.from !== void 0 ? { from: command2.from } : drawn ? {} : { from: 0 });
+          break;
+        }
+        break;
+      case "move": {
+        const e = _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT));
+        let dx = _nullishCoalesce(_optionalChain([command2, 'access', _15 => _15.by, 'optionalAccess', _16 => _16.x]), () => ( 0));
+        let dy = _nullishCoalesce(_optionalChain([command2, 'access', _17 => _17.by, 'optionalAccess', _18 => _18.y]), () => ( 0));
+        if (command2.to) {
+          const inv = _chunkXCXQDPIDcjs.invertMatrix.call(void 0, entry.parentWorld);
+          const target = _chunkXCXQDPIDcjs.applyMatrix.call(void 0, inv, command2.to);
+          dx = target.x - (entry.center.x + num("x"));
+          dy = target.y - (entry.center.y + num("y"));
+        }
+        seg("x", num("x") + dx, e);
+        seg("y", num("y") + dy, e);
+        break;
+      }
+      case "rotate":
+        seg("rotation", _nullishCoalesce(command2.to, () => ( num("rotation") + (_nullishCoalesce(command2.by, () => ( 0))))), _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+      case "scale": {
+        const to = typeof command2.to === "number" ? { x: command2.to, y: command2.to } : command2.to;
+        seg("scaleX", to.x, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        seg("scaleY", to.y, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+      }
+      case "fade":
+        seg("opacity", command2.to, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+      case "style":
+        if (command2.fill !== void 0) seg("fill", command2.fill, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        if (command2.stroke !== void 0) seg("stroke", command2.stroke, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        if (command2.strokeWidth !== void 0) seg("strokeWidth", command2.strokeWidth, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+      case "morph":
+        seg("shape", command2.into, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+      case "follow":
+        seg("follow", _nullishCoalesce(command2.to, () => ( 1)), _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)), start, end, { from: _nullishCoalesce(command2.from, () => ( 0)), path: command2.path, rotate: _nullishCoalesce(command2.rotate, () => ( false)) });
+        break;
+      case "pulse": {
+        const wave = { kind: "pulse", amount: _nullishCoalesce(command2.amount, () => ( 0.15)), count: _nullishCoalesce(command2.count, () => ( 1)) };
+        seg("scaleX", num("scaleX"), "linear", start, end, { wave });
+        seg("scaleY", num("scaleY"), "linear", start, end, { wave });
+        break;
+      }
+      case "shake":
+        seg("x", num("x"), "linear", start, end, { wave: { kind: "shake", amount: _nullishCoalesce(command2.amount, () => ( 8)), count: _nullishCoalesce(command2.count, () => ( 3)) } });
+        break;
+      case "effect":
+        seg(`effect:${command2.effect}:${command2.param}`, command2.to, _nullishCoalesce(ease, () => ( MOTION_EASE_IN_OUT)));
+        break;
+    }
+  }
+  for (const track of tracks.values()) track.sort((a, b) => a.start - b.start);
+  segments.sort((a, b) => a.start - b.start);
+  const duration = shots.length ? shots[shots.length - 1].end : 0;
+  const timeline = { duration, shots, commands, segments, tracks };
+  timelineCache.set(scene, timeline);
+  return timeline;
+}
+function motionShotAt(timeline, time) {
+  return _nullishCoalesce(timeline.shots.find((s) => time < s.end), () => ( timeline.shots[timeline.shots.length - 1]));
+}
+
+// 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', _19 => _19.controls, 'optionalAccess', _20 => _20.length])) return scene;
+  const map = /* @__PURE__ */ new Map();
+  for (const control of scene.controls) {
+    const value = values[control.name];
+    if (typeof value === "string" && _chunkA6PHCAGXcjs.normalizeTokenColor.call(void 0, value) !== null) map.set(control.default.toLowerCase(), value);
+  }
+  if (!map.size) return scene;
+  const walk = (v) => {
+    if (typeof v === "string") return _nullishCoalesce(map.get(v.toLowerCase()), () => ( v));
+    if (Array.isArray(v)) return v.map(walk);
+    if (v && typeof v === "object") return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, walk(x)]));
+    return v;
+  };
+  return { ...scene, artwork: walk(scene.artwork), shots: walk(scene.shots) };
+}
+function fadeColor(color, alpha) {
+  const hex = _chunkA6PHCAGXcjs.normalizeTokenColor.call(void 0, color);
+  if (hex === null) return color;
+  const c = _chunkA6PHCAGXcjs.hexToRgba.call(void 0, hex);
+  return _chunkA6PHCAGXcjs.rgbaToHex.call(void 0, c.r, c.g, c.b, c.a * alpha);
+}
+function fadePaint(paint, alpha) {
+  if (alpha >= 1 || paint == null || paint === "none") return paint;
+  if (typeof paint === "string") return fadeColor(paint, alpha);
+  if ("stops" in paint && Array.isArray(paint.stops)) return { ...paint, stops: paint.stops.map((s) => ({ ...s, opacity: (_nullishCoalesce(s.opacity, () => ( 1))) * alpha })) };
+  return paint;
+}
+function mapPaths(node, fn) {
+  if (node.type === "path") return fn(node);
+  return { ...node, children: node.children.map((c) => mapPaths(c, fn)) };
+}
+var morphCache = /* @__PURE__ */ new WeakMap();
+function morphBetween(a, b) {
+  let inner = morphCache.get(a);
+  if (!inner) morphCache.set(a, inner = /* @__PURE__ */ new WeakMap());
+  let morph = inner.get(b);
+  if (!morph) inner.set(b, morph = _chunkXCXQDPIDcjs.createVectorMorph.call(void 0, a, b, { id: a.id }));
+  return morph;
+}
+function shapeIn(entry, shape) {
+  if (shape === entry) return entry.node;
+  const m = _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.nodeMatrix.call(void 0, shape.node), shape.parentWorld), _chunkXCXQDPIDcjs.invertMatrix.call(void 0, entry.parentWorld));
+  return { ...shape.node, ..._chunkXCXQDPIDcjs.isIdentityMatrix.call(void 0, m) ? { transform: void 0 } : { transform: m } };
+}
+function shapeAt(entry, timeline, nodes, time) {
+  const track = timeline.tracks.get(motionTrackKey(entry.node.id, "shape"));
+  if (!_optionalChain([track, 'optionalAccess', _21 => _21.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;
+  const a = nodes.get(fromId);
+  const b = nodes.get(String(s.to));
+  if (!a || !b) return null;
+  const { eased } = segmentProgress(s, time);
+  const u = Math.min(1, Math.max(0, eased));
+  if (u <= 0) return a === entry ? null : shapeIn(entry, a);
+  if (u >= 1) return b === entry ? null : shapeIn(entry, b);
+  return morphBetween(shapeIn(entry, a), shapeIn(entry, b)).at(u);
+}
+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', _22 => _22[0]])));
+  if (!_optionalChain([s, 'optionalAccess', _23 => _23.path])) return null;
+  const path = nodes.get(s.path);
+  if (!path || path.node.type !== "path") return null;
+  const progress = Number(trackValue(track, time));
+  if (!(progress >= 0)) return null;
+  try {
+    const bezier = _chunkXCXQDPIDcjs.vectorPathWorldBezier.call(void 0, path.node, path.parentWorld, { effects: false });
+    const at = _chunkO2UH7LZEcjs.bezierPathPointAtLength.call(void 0, bezier, Math.min(1, Math.max(0, progress)) * _chunkO2UH7LZEcjs.bezierPathLength.call(void 0, bezier));
+    if (!at) return null;
+    const p = _chunkXCXQDPIDcjs.applyMatrix.call(void 0, _chunkXCXQDPIDcjs.invertMatrix.call(void 0, entry.parentWorld), { x: at.point[0], y: at.point[1] });
+    return { x: p.x, y: p.y, angle: s.rotate ? at.angle * 180 / Math.PI : 0 };
+  } catch (e3) {
+    return null;
+  }
+}
+function motionNodeOffset(entry, timeline, time, nodes = indexMotionNodes([entry.node])) {
+  const read = (p, rest) => {
+    const v = trackValue(timeline.tracks.get(motionTrackKey(entry.node.id, p)), time);
+    return typeof v === "number" ? v : rest;
+  };
+  if (!TRANSFORM_PROPS.some((p) => timeline.tracks.has(motionTrackKey(entry.node.id, p)))) return null;
+  let dx = read("x", 0);
+  let dy = read("y", 0);
+  let rotation = read("rotation", 0);
+  const scaleX = read("scaleX", 1);
+  const scaleY = read("scaleY", 1);
+  const follow = followAt(entry, timeline, nodes, time);
+  if (follow) {
+    dx += follow.x - entry.center.x;
+    dy += follow.y - entry.center.y;
+    rotation += follow.angle;
+  }
+  const c = entry.center;
+  const matrix = _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.scaleMatrix.call(void 0, scaleX, scaleY, c), _chunkXCXQDPIDcjs.rotateMatrix.call(void 0, rotation, c)), _chunkXCXQDPIDcjs.translateMatrix.call(void 0, dx, dy));
+  return { matrix, dx, dy, rotation, scaleX, scaleY };
+}
+function motionFrameAt(scene, time, options = {}) {
+  const s = applyMotionControlValues(scene, options.values);
+  const timeline = compileMotionScene(s);
+  const nodes = indexMotionNodes(s.artwork.nodes);
+  const drawOn = options.draw !== false;
+  const value = (id, p) => trackValue(timeline.tracks.get(motionTrackKey(id, p)), time);
+  const animated = new Set(timeline.segments.map((seg) => seg.node));
+  const visit = (node) => {
+    let out = node.type === "group" ? { ...node, children: node.children.map(visit) } : node;
+    if (!animated.has(node.id)) return out;
+    const entry = nodes.get(node.id);
+    if (!entry) return out;
+    const id = node.id;
+    const shape = shapeAt(entry, timeline, nodes, time);
+    if (shape) {
+      const { name, visible, opacity: opacity2, locked } = node;
+      out = { ...shape, id, ...name ? { name } : {}, ...locked ? { locked } : {}, visible, ...opacity2 !== void 0 ? { opacity: opacity2 } : {} };
+      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', _24 => _24.effects, 'optionalAccess', _25 => _25.length])) {
+      out = {
+        ...out,
+        effects: out.effects.map((effect) => {
+          let params = effect.params;
+          for (const key of effectTracks) {
+            const [, effectId, param] = key.split("\0")[1].split(":");
+            if (effectId !== effect.id) continue;
+            const v = trackValue(timeline.tracks.get(key), time);
+            if (typeof v === "number") params = { ...params, [param]: v };
+          }
+          return params === effect.params ? effect : { ...effect, params };
+        })
+      };
+    }
+    const fill = value(id, "fill");
+    const stroke = value(id, "stroke");
+    const strokeWidth = value(id, "strokeWidth");
+    const fillOpacity = value(id, "fillOpacity");
+    const drawStart = value(id, "drawStart");
+    const drawEnd = value(id, "drawEnd");
+    const draw = drawOn && (drawStart !== void 0 || drawEnd !== void 0);
+    if (fill !== void 0 || stroke !== void 0 || strokeWidth !== void 0 || fillOpacity !== void 0 || draw) {
+      out = mapPaths(out, (path) => {
+        let p = path;
+        if (typeof fill === "string") p = { ...p, fill };
+        if (typeof stroke === "string") p = { ...p, stroke };
+        if (typeof strokeWidth === "number") p = { ...p, strokeWidth: Math.max(0, tidy(strokeWidth)) };
+        if (typeof fillOpacity === "number" && fillOpacity < 1) p = { ...p, fill: fadePaint(p.fill, Math.max(0, fillOpacity)) };
+        if (draw) {
+          const start = Math.min(1, Math.max(0, typeof drawStart === "number" ? drawStart : 0));
+          const end = Math.min(1, Math.max(0, typeof drawEnd === "number" ? drawEnd : 1));
+          if (start > 0 || end < 1) {
+            const trim = _chunkXCXQDPIDcjs.createVectorEffect.call(void 0, "trim", MOTION_DRAW_EFFECT_ID, { start: tidy(start * 100), end: tidy(end * 100) });
+            p = { ...p, effects: [trim, ...(_nullishCoalesce(p.effects, () => ( []))).filter((e) => e.id !== MOTION_DRAW_EFFECT_ID)] };
+          }
+        }
+        return p;
+      });
+    }
+    const opacity = value(id, "opacity");
+    if (typeof opacity === "number") {
+      const o = Math.min(1, Math.max(0, tidy(opacity)));
+      out = { ...out, opacity: o };
+      if (o >= 1) delete out.opacity;
+    }
+    const offset = options.offsets === false ? null : motionNodeOffset(entry, timeline, time, nodes);
+    if (offset && !_chunkXCXQDPIDcjs.isIdentityMatrix.call(void 0, offset.matrix)) {
+      const m = _chunkXCXQDPIDcjs.multiplyMatrices.call(void 0, _chunkXCXQDPIDcjs.nodeMatrix.call(void 0, out), offset.matrix).map(tidy);
+      out = { ...out, transform: m };
+    }
+    return out;
+  };
+  const document = { ...s.artwork, nodes: s.artwork.nodes.map(visit) };
+  const cam = trackValue(timeline.tracks.get(motionTrackKey("", "camera")), time);
+  const box = 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]) } };
+}
+function motionFrameToSvg(scene, time, options = {}) {
+  const frame = motionFrameAt(scene, time, options);
+  return withViewBox(_chunkXCXQDPIDcjs.vectorDocumentToSvg.call(void 0, frame.document, options), frame.camera);
+}
+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)}"`);
+}
+
+// src/animation-editor/check.ts
+var MOTION_MIN_CHANGE_MS = 120;
+var NUMERIC_PARAMS = (node, effectId) => {
+  const effect = _optionalChain([node, 'access', _26 => _26.effects, 'optionalAccess', _27 => _27.find, 'call', _28 => _28((e) => e.id === effectId)]);
+  if (!effect) return null;
+  return Object.entries(effect.params).filter(([, v]) => typeof v === "number").map(([k]) => k);
+};
+function usesColor(scene, color) {
+  const target = color.toLowerCase();
+  let found = false;
+  const walk = (v) => {
+    if (found) return;
+    if (typeof v === "string") found = v.toLowerCase() === target;
+    else if (Array.isArray(v)) v.forEach(walk);
+    else if (v && typeof v === "object") Object.values(v).forEach(walk);
+  };
+  walk(scene.artwork);
+  walk(scene.shots);
+  return found;
+}
+function visibleAt(timeline, id, time, node) {
+  const num = (p, rest) => {
+    const v = trackValue(timeline.tracks.get(motionTrackKey(id, p)), time);
+    return typeof v === "number" ? v : rest;
+  };
+  if (node.visible === false) return false;
+  if (num("opacity", _nullishCoalesce(node.opacity, () => ( 1))) <= 0.01) return false;
+  if (Math.abs(num("scaleX", 1) * num("scaleY", 1)) <= 1e-4) return false;
+  const hasFill = node.type === "path" ? !!node.fill && node.fill !== "none" : _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node).some((p) => p.fill && p.fill !== "none");
+  return num("drawEnd", 1) > 0.01 || hasFill && num("fillOpacity", 1) > 0.01;
+}
+function checkMotionScene(scene) {
+  const issues = [];
+  const nodes = indexMotionNodes(scene.artwork.nodes);
+  const ids = [...nodes.keys()];
+  const timeline = compileMotionScene(scene);
+  const artAspect = scene.artwork.width / scene.artwork.height;
+  if (!scene.shots.length) issues.push(motionIssue("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(motionIssue("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(motionIssue(code, `There is no ${what} ${namedWithSuggestion(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) {
+      const c = shot.camera;
+      if (!(c.width > 0 && c.height > 0)) issues.push(motionIssue("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(motionIssue("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 (!shot.run.length && !shot.camera && shotIndex2 > 0) issues.push(motionIssue("empty-shot", "This shot only holds; add commands or a camera move, or remove it.", { shot: shot.id }));
+    shot.run.forEach((command2, i) => {
+      const where = { shot: shot.id, command: i };
+      if (command2.type === "wait") return;
+      const targets = command2.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(motionIssue("too-fast", `This ${command2.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 (command2.type === "follow" && known(command2.path, "unknown-path", "path", where) && nodes.get(command2.path).node.type !== "path")
+        issues.push(motionIssue("not-a-path", `"${command2.path}" is a group; follow a single path node.`, { ...where, ids: [command2.path] }));
+      if (command2.type === "morph") known(command2.into, "unknown-shape", "shape", where);
+      if (command2.type === "style") {
+        for (const key of ["fill", "stroke"]) {
+          const color = command2[key];
+          if (color === void 0) continue;
+          if (_chunkA6PHCAGXcjs.normalizeTokenColor.call(void 0, color) === null) {
+            issues.push(motionIssue("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] : _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node);
+            if (paths.some((p) => p[key] !== void 0 && p[key] !== null && typeof p[key] !== "string"))
+              issues.push(motionIssue("paint-not-color", `"${id}" has a gradient ${key}; it switches to ${color} at the end instead of blending.`, { ...where, ids: [id] }));
+          }
+        }
+      }
+      if (command2.type === "effect") {
+        for (const id of targets) {
+          const node = nodes.get(id).node;
+          const params = NUMERIC_PARAMS(node, command2.effect);
+          const effects = (_nullishCoalesce(node.effects, () => ( []))).map((e) => e.id);
+          if (!params)
+            issues.push(motionIssue("unknown-effect", `"${id}" has no effect ${namedWithSuggestion(command2.effect, effects)}${effects.length ? `; its effects are ${effects.map((e) => `"${e}"`).join(", ")}` : "; it has no live effects"}.`, { ...where, ids: [id] }));
+          else if (!params.includes(command2.param))
+            issues.push(motionIssue("unknown-effect-param", `Effect "${command2.effect}" has no numeric parameter ${namedWithSuggestion(command2.param, params)}; use one of ${params.join(", ")}.`, { ...where, ids: [id] }));
+        }
+      }
+      if (timing) {
+        for (const id of targets) {
+          const node = nodes.get(id).node;
+          const before = Math.max(0, timing.start - 0.5);
+          const visible = timing.start > 0 ? visibleAt(timeline, id, before, node) : node.visible !== false;
+          if (command2.type === "enter" && visible && timing.start > 0)
+            issues.push(motionIssue("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 = command2.type === "exit" ? timing.start + 0.5 : (timing.start + timing.end) / 2;
+          if (command2.type !== "enter" && command2.type !== "draw" && !visibleAt(timeline, id, probe, node))
+            issues.push(motionIssue("exit-hidden", `"${id}" is hidden when this ${command2.type} starts, so it is not seen; enter it first.`, { ...where, ids: [id] }));
+        }
+      }
+    });
+  });
+  for (const [key, track] of timeline.tracks) {
+    for (let i = 1; i < track.length; i++) {
+      const a = track[i - 1];
+      const b = track[i];
+      if (b.start < a.end - 1 && (a.shot !== b.shot || a.command !== b.command)) {
+        const property = key.split("\0")[1];
+        if (!a.node) continue;
+        issues.push(
+          motionIssue("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]
+          })
+        );
+      }
+    }
+  }
+  const reported = /* @__PURE__ */ new Set();
+  for (const timing of timeline.commands) {
+    const command2 = scene.shots[timing.shotIndex].run[timing.command];
+    if (command2.type === "wait" || command2.type === "exit") continue;
+    const frame = motionFrameAt(scene, timing.end);
+    const cam = frame.camera;
+    const docIndex = indexMotionNodes(frame.document.nodes);
+    for (const id of command2.targets) {
+      const b = _optionalChain([docIndex, 'access', _29 => _29.get, 'call', _30 => _30(id), 'optionalAccess', _31 => _31.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(motionIssue("out-of-frame", `"${id}" is outside the camera when this ${command2.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(motionIssue("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(motionIssue("scene-too-long", `The scene runs ${seconds} s, past its ${max} s target; shorten holds or durations.`, { measured: seconds, needed: max, unit: "s" }));
+    if (seconds < min) issues.push(motionIssue("scene-too-short", `The scene runs ${seconds} s, under its ${min} s target; hold longer or add shots.`, { measured: seconds, needed: min, unit: "s" }));
+  }
+  return issues;
+}
+
+// src/animation-editor/edit.ts
+var MOTION_EDIT_OPS = [
+  "set_settings",
+  "insert_shots",
+  "update_shot",
+  "delete_shots",
+  "move_shot",
+  "add_commands",
+  "update_command",
+  "delete_commands",
+  "set_artwork",
+  "set_controls",
+  "replace_scene"
+];
+var EditError = class extends Error {
+};
+var fail = (message) => {
+  throw new EditError(message);
+};
+function shotIndex(scene, id) {
+  const i = scene.shots.findIndex((s) => s.id === id);
+  if (i < 0) fail(`There is no shot ${namedWithSuggestion(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) {
+  if (at === void 0) return length;
+  if (!Number.isInteger(at) || at < 0 || at > length) fail(`${what} must be a whole number from 0 to ${length} (got ${at}).`);
+  return at;
+}
+var replaceShot = (scene, index, shot) => ({ ...scene, shots: scene.shots.map((s, i) => i === index ? shot : 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}`;
+}
+function applyOne(scene, edit) {
+  switch (edit.op) {
+    case "set_settings": {
+      const next = { ...scene };
+      if (edit.name !== void 0) next.name = edit.name;
+      if (edit.description === null) delete next.description;
+      else if (edit.description !== void 0) next.description = edit.description;
+      if (edit.loop !== void 0) next.loop = edit.loop;
+      if (edit.fps !== void 0) next.fps = edit.fps;
+      if (edit.target === null) delete next.target;
+      else if (edit.target !== void 0) next.target = edit.target;
+      return next;
+    }
+    case "insert_shots": {
+      if (!edit.shots.length) fail("Give at least one shot.");
+      edit.shots.forEach((shot, i) => {
+        const problems = shotShapeProblems(shot, `Shot ${i + 1}`);
+        if (problems.length) fail(problems.join(" "));
+      });
+      const ids = new Set(scene.shots.map((s) => s.id));
+      for (const shot of edit.shots) {
+        if (ids.has(shot.id)) fail(`Shot id "${shot.id}" is already used; choose another (e.g. "${freshShotId(scene, shot.id)}").`);
+        ids.add(shot.id);
+      }
+      const at = position(edit.at, scene.shots.length, '"at"');
+      return { ...scene, shots: [...scene.shots.slice(0, at), ...edit.shots, ...scene.shots.slice(at)] };
+    }
+    case "update_shot": {
+      const i = shotIndex(scene, edit.shot);
+      const shot = { ...scene.shots[i], ..._nullishCoalesce(edit.set, () => ( {})) };
+      for (const key of _nullishCoalesce(edit.remove, () => ( []))) delete shot[key];
+      if (shot.id !== edit.shot && scene.shots.some((s) => s.id === shot.id)) fail(`Shot id "${shot.id}" is already used; choose another.`);
+      const problems = shotShapeProblems(shot, `Shot "${edit.shot}"`);
+      if (problems.length) fail(problems.join(" "));
+      return replaceShot(scene, i, shot);
+    }
+    case "delete_shots": {
+      if (!edit.shots.length) fail("Give at least one shot id.");
+      edit.shots.forEach((id) => shotIndex(scene, id));
+      const drop = new Set(edit.shots);
+      return { ...scene, shots: scene.shots.filter((s) => !drop.has(s.id)) };
+    }
+    case "move_shot": {
+      const i = shotIndex(scene, edit.shot);
+      const to = position(edit.to, scene.shots.length - 1, '"to"');
+      const shots = [...scene.shots];
+      const [shot] = shots.splice(i, 1);
+      shots.splice(to, 0, shot);
+      return { ...scene, shots };
+    }
+    case "add_commands": {
+      const i = shotIndex(scene, edit.shot);
+      if (!edit.commands.length) fail("Give at least one command.");
+      edit.commands.forEach((command2, k) => {
+        const problems = commandShapeProblems(command2, `Command ${k + 1}`);
+        if (problems.length) fail(problems.join(" "));
+      });
+      const run = scene.shots[i].run;
+      const at = position(edit.at, run.length, '"at"');
+      return replaceShot(scene, i, { ...scene.shots[i], run: [...run.slice(0, at), ...edit.commands, ...run.slice(at)] });
+    }
+    case "update_command": {
+      const i = shotIndex(scene, edit.shot);
+      const run = scene.shots[i].run;
+      if (!Number.isInteger(edit.command) || edit.command < 0 || edit.command >= run.length)
+        fail(`Shot "${edit.shot}" has ${run.length} command${run.length === 1 ? "" : "s"}; "command" must be an index from 0 to ${run.length - 1} (got ${edit.command}).`);
+      const command2 = { ...run[edit.command], ..._nullishCoalesce(edit.set, () => ( {})) };
+      for (const key of _nullishCoalesce(edit.remove, () => ( []))) {
+        if (key === "type") fail('"type" cannot be removed; replace the command instead.');
+        delete command2[key];
+      }
+      const problems = commandShapeProblems(command2, `Command ${edit.command}`);
+      if (problems.length) fail(problems.join(" "));
+      return replaceShot(scene, i, { ...scene.shots[i], run: run.map((c, k) => k === edit.command ? command2 : c) });
+    }
+    case "delete_commands": {
+      const i = shotIndex(scene, edit.shot);
+      const run = scene.shots[i].run;
+      if (!edit.commands.length) fail("Give at least one command index.");
+      for (const k of edit.commands)
+        if (!Number.isInteger(k) || k < 0 || k >= run.length) fail(`Shot "${edit.shot}" has no command ${k}; indexes run from 0 to ${run.length - 1}.`);
+      const drop = new Set(edit.commands);
+      return replaceShot(scene, i, { ...scene.shots[i], run: run.filter((_, k) => !drop.has(k)) });
+    }
+    case "set_artwork":
+      return { ...scene, artwork: edit.artwork };
+    case "set_controls": {
+      const next = { ...scene, controls: edit.controls };
+      if (!edit.controls.length) delete next.controls;
+      if (edit.presets !== void 0) {
+        if (edit.presets.length) next.presets = edit.presets;
+        else delete next.presets;
+      }
+      const names = new Set(edit.controls.map((c) => c.name));
+      for (const preset of _nullishCoalesce(next.presets, () => ( [])))
+        for (const key of Object.keys(preset.values))
+          if (!names.has(key)) fail(`Preset "${preset.name}" sets ${namedWithSuggestion(key, names)}, which is not a control.`);
+      return next;
+    }
+    case "replace_scene":
+      return edit.scene;
+  }
+}
+function errorKeys(issues) {
+  return new Set(issues.filter((i) => i.severity === "error").map(motionIssueKey));
+}
+function editHints(before, after) {
+  const old = new Set(before.map(motionIssueKey));
+  return after.filter((i) => i.code === "overlap" && !old.has(motionIssueKey(i))).map(motionIssueLine);
+}
+function applyMotionEdits(scene, edits) {
+  const list = Array.isArray(edits) ? edits : [edits];
+  const before = checkMotionScene(scene);
+  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', _32 => _32.op])}): ` : "";
+    if (!edit || !MOTION_EDIT_OPS.includes(edit.op))
+      return { ok: false, error: `${prefix}Unknown op ${namedWithSuggestion(String(_optionalChain([edit, 'optionalAccess', _33 => _33.op])), MOTION_EDIT_OPS)}. Nothing was changed.` };
+    try {
+      next = applyOne(next, edit);
+    } catch (error) {
+      if (error instanceof EditError) return { ok: false, error: `${prefix}${error.message} Nothing was changed.` };
+      throw error;
+    }
+    const problems = motionSceneShapeProblems(next);
+    if (problems.length) return { ok: false, error: `${prefix}Nothing was changed: ${problems.join(" ")}` };
+  }
+  const issues = checkMotionScene(next);
+  const had = errorKeys(before);
+  const added = issues.filter((i) => i.severity === "error" && !had.has(motionIssueKey(i)));
+  if (added.length) return { ok: false, error: `Nothing was changed: ${added.map(motionIssueLine).join(" ")}` };
+  return { ok: true, scene: next, issues, hints: editHints(before, issues) };
+}
+function createMotionScene(artwork, init = {}) {
+  return { version: 1, name: _nullishCoalesce(init.name, () => ( "animation")), ...init, artwork, shots: _nullishCoalesce(init.shots, () => ( [])) };
+}
+
+// src/animation-editor/flair.ts
+var FLAIR_EASES = {
+  linear: (t) => t,
+  "in-out": (t) => t < 0.5 ? 4 * t * t * t : 1 - (-2 * t + 2) ** 3 / 2,
+  out: (t) => 1 - (1 - t) ** 3
+};
+function flairEaseFor(ease) {
+  for (const name of ["linear", "out", "in-out"]) {
+    let worst = 0;
+    for (let i = 1; i < 40; i++) {
+      const t = i / 40;
+      worst = Math.max(worst, Math.abs(_chunkXZ4L3R4Kcjs.evaluateEasing.call(void 0, ease, t, 1e3) - FLAIR_EASES[name](t)));
+    }
+    if (worst < 0.01) return name;
+  }
+  return void 0;
+}
+var TRANSFORM_PROPS2 = ["x", "y", "rotation", "scaleX", "scaleY", "follow"];
+var LINEAR_TRANSFORM = /* @__PURE__ */ new Set(["x", "y", "rotation", "scaleX", "scaleY"]);
+function hex6(color) {
+  const hex = _chunkA6PHCAGXcjs.normalizeTokenColor.call(void 0, color);
+  return hex ? hex.slice(0, 7) : "#000000";
+}
+function toFlairSvgMotion(scene, options = {}) {
+  const fps = _nullishCoalesce(_nullishCoalesce(options.fps, () => ( scene.fps)), () => ( 30));
+  const precision = _nullishCoalesce(options.precision, () => ( 3));
+  const round2 = (n) => Math.round(n * 10 ** precision) / 10 ** precision;
+  const f = (n) => String(round2(n));
+  const timeline = compileMotionScene(scene);
+  const nodes = indexMotionNodes(scene.artwork.nodes);
+  const notes = [];
+  const channels = [];
+  const track = (id, p) => _nullishCoalesce(timeline.tracks.get(motionTrackKey(id, p)), () => ( []));
+  const owner = (path, p) => {
+    const entry = nodes.get(path.id);
+    if (!entry) return void 0;
+    return [...entry.ancestors, path.id].find((id) => timeline.tracks.has(motionTrackKey(id, p)));
+  };
+  const animatedNodes = new Set(timeline.segments.map((s) => s.node).filter(Boolean));
+  const pathsSeen = /* @__PURE__ */ new Set();
+  for (const id of animatedNodes) {
+    const entry = nodes.get(id);
+    const node = entry.node;
+    if (timeline.tracks.has(motionTrackKey(id, "opacity")))
+      channels.push({ id, kind: "attr", attr: "opacity", segments: [...track(id, "opacity")], exact: (s) => !s.wave, value: (t) => round2(Math.min(1, Math.max(0, Number(trackValue(track(id, "opacity"), t))))) });
+    const transformSegments = TRANSFORM_PROPS2.flatMap((p) => track(id, p));
+    if (transformSegments.length) {
+      const base = node.transform ? ` matrix(${node.transform.map(f).join(" ")})` : "";
+      const c = entry.center;
+      channels.push({
+        id,
+        kind: "attr",
+        attr: "transform",
+        segments: transformSegments,
+        exact: (s) => LINEAR_TRANSFORM.has(s.property) && !s.wave,
+        value: (t) => {
+          const o = motionNodeOffset(entry, timeline, t, nodes);
+          return `translate(${f(o.dx)} ${f(o.dy)}) rotate(${f(o.rotation)} ${f(c.x)} ${f(c.y)}) translate(${f(c.x)} ${f(c.y)}) scale(${f(o.scaleX)} ${f(o.scaleY)}) translate(${f(-c.x)} ${f(-c.y)})${base}`;
+        }
+      });
+    }
+    const paths = node.type === "path" ? [node] : _chunkXCXQDPIDcjs.collectPathNodes.call(void 0, node);
+    for (const path of paths) {
+      if (pathsSeen.has(path.id)) continue;
+      pathsSeen.add(path.id);
+      const paint = (p, attr) => {
+        const from = owner(path, p);
+        if (from) channels.push({ id: path.id, kind: "attr", attr, segments: [...track(from, p)], exact: () => true, value: (t) => hex6(trackValue(track(from, p), t)) });
+      };
+      paint("fill", "fill");
+      paint("stroke", "stroke");
+      const width = owner(path, "strokeWidth");
+      if (width) channels.push({ id: path.id, kind: "attr", attr: "stroke-width", segments: [...track(width, "strokeWidth")], exact: () => true, value: (t) => round2(Number(trackValue(track(width, "strokeWidth"), t))) });
+      const fade = owner(path, "fillOpacity");
+      if (fade) channels.push({ id: path.id, kind: "attr", attr: "fill-opacity", segments: [...track(fade, "fillOpacity")], exact: () => true, value: (t) => round2(Number(trackValue(track(fade, "fillOpacity"), t))) });
+      const draw = owner(path, "drawEnd");
+      if (draw) channels.push({ id: path.id, kind: "draw", segments: [...track(draw, "drawEnd")], exact: () => true, value: (t) => round2(Math.min(1, Math.max(0, Number(trackValue(track(draw, "drawEnd"), t))))) });
+      if (owner(path, "drawStart")) notes.push(`"${path.id}": drawing from a start other than 0 is not exported; Flair draws from the start of the path.`);
+    }
+    const shapeSegments = [...timeline.tracks.entries()].filter(([k]) => k.startsWith(`${id}\0`) && (k.endsWith("\0shape") || k.includes("\0effect:"))).flatMap(([, v]) => v);
+    if (shapeSegments.length) {
+      if (node.type !== "path") notes.push(`"${id}" is a group: its morph or effect animation is not exported (Flair tweens one path's "d").`);
+      else {
+        const inverse = _chunkXCXQDPIDcjs.invertMatrix.call(void 0, _chunkXCXQDPIDcjs.nodeMatrix.call(void 0, node));
+        channels.push({
+          id,
+          kind: "attr",
+          attr: "d",
+          segments: shapeSegments,
+          exact: () => false,
+          value: (t) => {
+            const frame = motionFrameAt(scene, t, { draw: false, offsets: false });
+            const now = _chunkXCXQDPIDcjs.expandVectorAppearance.call(void 0, _optionalChain([indexMotionNodes, 'call', _34 => _34(frame.document.nodes), 'access', _35 => _35.get, 'call', _36 => _36(id), 'optionalAccess', _37 => _37.node]));
+            if (!now || now.type !== "path") return "";
+            const bezier = _chunkO2UH7LZEcjs.transformBezierPath.call(void 0, _chunkXCXQDPIDcjs.vectorPathWorldBezier.call(void 0, now, _chunkXCXQDPIDcjs.IDENTITY_MATRIX, { effects: false }), inverse);
+            return _chunkO2UH7LZEcjs.bezierPathToSvg.call(void 0, bezier, { precision: Math.min(precision, 2) });
+          }
+        });
+      }
+    }
+  }
+  const camera = track("", "camera");
+  if (camera.length) channels.push({ id: "", kind: "view", segments: [...camera], exact: () => true, value: (t) => trackValue(camera, t).map(round2) });
+  const animate = [];
+  let sampled = 0;
+  const same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+  const emit = (channel, delay, ms, from, to, ease) => {
+    const base = { ...channel.id ? { id: channel.id } : {}, ...delay > 0 ? { delay: round2(delay) } : {}, ms: round2(ms), ease };
+    if (channel.kind === "view") animate.push({ ...base, view: to });
+    else if (channel.kind === "draw") animate.push({ ...base, draw: [from, to] });
+    else animate.push({ ...base, attrs: { [channel.attr]: [from, to] } });
+  };
+  for (const channel of channels) {
+    const cuts = channel.segments.filter((s) => s.end <= s.start);
+    for (const cut of cuts) emit(channel, cut.start, 0, channel.value(Math.max(0, cut.start - 1e-3)), channel.value(cut.start), "linear");
+    const times = [...new Set(channel.segments.flatMap((s) => [s.start, s.end]))].sort((a, b) => a - b);
+    for (let i = 0; i + 1 < times.length; i++) {
+      const a = times[i];
+      const b = times[i + 1];
+      const active = channel.segments.filter((s) => s.start < b && s.end > a);
+      if (!active.length) continue;
+      const first = active[0];
+      const together = active.every((x) => x.start === a && x.end === b && channel.exact(x) && JSON.stringify(x.ease) === JSON.stringify(first.ease));
+      const ease = together ? flairEaseFor(first.ease) : void 0;
+      if (ease) {
+        const from = channel.value(a);
+        const to = channel.value(b);
+        if (!same(from, to) || channel.kind === "view") emit(channel, a, b - a, from, to, ease);
+        continue;
+      }
+      const n = 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;
+        const next = channel.value(t1);
+        if (!same(prev, next)) {
+          emit(channel, t0, t1 - t0, prev, next, "linear");
+          sampled++;
+        }
+        prev = next;
+      }
+    }
+  }
+  animate.sort((x, y) => (_nullishCoalesce(x.delay, () => ( 0))) - (_nullishCoalesce(y.delay, () => ( 0))));
+  let svg = _chunkXCXQDPIDcjs.vectorDocumentToSvg.call(void 0, { ...scene.artwork, nodes: _chunkXCXQDPIDcjs.expandVectorAppearances.call(void 0, scene.artwork.nodes) }, { pretty: false, precision });
+  const lastChange = animate.reduce((m, a) => Math.max(m, (_nullishCoalesce(a.delay, () => ( 0))) + (_nullishCoalesce(a.ms, () => ( 0)))), 0);
+  let motion = { svg, animate };
+  if (_optionalChain([scene, 'access', _38 => _38.controls, 'optionalAccess', _39 => _39.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} -->`);
+    const header = svg.indexOf("-->") + 3;
+    svg = svg.slice(0, header) + swap(svg.slice(header));
+    motion = { svg, animate: animate.map((a) => a.attrs ? { ...a, attrs: Object.fromEntries(Object.entries(a.attrs).map(([k, [x, y]]) => [k, [typeof x === "string" ? swap(x) : x, typeof y === "string" ? swap(y) : y]])) } : a) };
+  }
+  return { motion, duration: timeline.duration, hold: Math.max(0, round2(timeline.duration - lastChange)), sampled, notes: [...new Set(notes)] };
+}
+var kebab = (text) => text.trim().replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase() || "animation";
+function toFlairVectorEffect(scene, options = {}) {
+  const out = toFlairSvgMotion(scene, options);
+  return {
+    kind: "vector",
+    id: _nullishCoalesce(options.id, () => ( kebab(scene.name))),
+    name: _nullishCoalesce(options.name, () => ( scene.name)),
+    description: _nullishCoalesce(_nullishCoalesce(options.description, () => ( scene.description)), () => ( "")),
+    category: _nullishCoalesce(options.category, () => ( "icon")),
+    tags: _nullishCoalesce(options.tags, () => ( [])),
+    motion: out.motion,
+    hold: out.hold,
+    ..._optionalChain([scene, 'access', _40 => _40.presets, 'optionalAccess', _41 => _41.length]) ? { presets: scene.presets } : {},
+    ...options.trigger ? { trigger: options.trigger } : {}
+  };
+}
+function toFlairEffectDocument(scene, options = {}) {
+  const out = toFlairSvgMotion(scene, options);
+  return {
+    version: 1,
+    name: scene.name,
+    effect: { kind: "vector", motion: out.motion, hold: out.hold },
+    values: Object.fromEntries((_nullishCoalesce(scene.controls, () => ( []))).map((c) => [c.name, c.default])),
+    tracks: {},
+    duration: out.duration,
+    loop: (_nullishCoalesce(scene.loop, () => ( "none"))) !== "none",
+    presets: _nullishCoalesce(scene.presets, () => ( []))
+  };
+}
+
+// src/animation-editor/controller.ts
+var BLANK = { width: 800, height: 450, background: "#ffffff", nodes: [] };
+var AnimationEditorController = (_class = class {
+  
+  
+  
+  
+  __init() {this.selection = null}
+  
+  __init2() {this.error = null}
+  __init3() {this.revision = 0}
+  __init4() {this.applying = false}
+  
+  __init5() {this.listeners = /* @__PURE__ */ new Set()}
+  __init6() {this.unsubscribers = []}
+  
+  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);
+    this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.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;
+    this.player = new (0, _chunkO4ONBPZWcjs.AnimationPlayer)({ clock: options.clock, duration: () => compileMotionScene(this.scene).duration, loop: _nullishCoalesce(this.scene.loop, () => ( "none")) });
+    this.state = this.computeState();
+    this.connect();
+  }
+  connect() {
+    if (this.unsubscribers.length) return;
+    this.unsubscribers.push(
+      this.player.subscribe(() => this.notify()),
+      this.history.subscribe(() => {
+        if (!this.applying) this.notify();
+      })
+    );
+  }
+  /**
+   * Pauses and stops listening to the player and history. Subscribing again reconnects, so a
+   * controller survives React StrictMode's unmount / remount.
+   */
+  destroy() {
+    this.player.pause();
+    this.unsubscribers.splice(0).forEach((u) => u());
+  }
+  __init7() {this.getState = () => this.state}
+  __init8() {this.subscribe = (listener) => {
+    this.connect();
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }}
+  /** The current scene (immutable; edit through the controller). */
+  getScene() {
+    return this.scene;
+  }
+  computeState() {
+    const timeline = compileMotionScene(this.scene);
+    const p = this.player.getState();
+    const h = this.history.getState();
+    return {
+      scene: this.scene,
+      duration: timeline.duration,
+      shots: timeline.shots,
+      issues: this.issues,
+      time: p.time,
+      playing: p.playing,
+      loop: p.loop,
+      currentShot: _nullishCoalesce(_optionalChain([motionShotAt, 'call', _42 => _42(timeline, p.time), 'optionalAccess', _43 => _43.id]), () => ( null)),
+      selection: this.selection,
+      readOnly: this.readOnly,
+      error: this.error,
+      canUndo: h.canUndo,
+      canRedo: h.canRedo,
+      undoLabel: h.undoName,
+      redoLabel: h.redoName,
+      revision: this.revision
+    };
+  }
+  notify() {
+    this.revision++;
+    this.state = this.computeState();
+    const state = this.state;
+    this.listeners.forEach((listener) => {
+      try {
+        listener(state);
+      } catch (error) {
+        console.error("[AnimationEditorController] Error in state listener:", error);
+      }
+    });
+  }
+  setScene(scene) {
+    this.applying = true;
+    try {
+      this.scene = scene;
+      this.issues = checkMotionScene(scene);
+      if (this.selection) {
+        const shot = scene.shots.find((s) => s.id === this.selection.shot);
+        if (!shot) this.selection = null;
+        else if (this.selection.command !== void 0 && this.selection.command >= shot.run.length) this.selection = { shot: shot.id };
+      }
+      this.player.setLoop(_nullishCoalesce(scene.loop, () => ( "none")));
+      this.player.setDuration(() => compileMotionScene(this.scene).duration);
+    } finally {
+      this.applying = false;
+    }
+    this.notify();
+    _optionalChain([this, 'access', _44 => _44.onChange, 'optionalCall', _45 => _45(scene)]);
+  }
+  commit(label, next) {
+    const before = this.scene;
+    this.error = null;
+    if (next === before) {
+      this.notify();
+      return;
+    }
+    const command2 = {
+      name: label,
+      tag: "animation-editor",
+      execute: () => this.setScene(next),
+      undo: () => this.setScene(before),
+      redo: () => this.setScene(next)
+    };
+    this.history.execute(command2);
+  }
+  refuse(message) {
+    this.error = message;
+    this.notify();
+    return { ok: false, error: message };
+  }
+  /** Why edits are refused now, or `null` when they are allowed. */
+  readOnlyReason() {
+    return this.readOnly ? "The animation is read-only." : null;
+  }
+  /**
+   * Applies edits as one undo step, all or nothing (see `applyMotionEdits`). With
+   * `dryRun` it reports what would happen and changes nothing.
+   */
+  apply(edits, label = "Edit animation", options = {}) {
+    const reason = this.readOnlyReason();
+    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);
+    return result;
+  }
+  /** Replaces the artwork (e.g. from a vector editor's `onChange`), as one undo step. */
+  setArtwork(artwork, label = "Change artwork") {
+    return this.apply({ op: "set_artwork", artwork }, label);
+  }
+  /** Opens a scene (JSON or object). `clearHistory` drops the undo stack (opening a file); otherwise it is one undo step. */
+  load(scene, options = {}) {
+    let parsed;
+    try {
+      parsed = parseMotionScene(scene);
+    } catch (error) {
+      return this.refuse(error.message);
+    }
+    if (options.clearHistory) {
+      this.history.clear();
+      this.error = null;
+      this.selection = null;
+      this.setScene(parsed);
+      this.player.seek(0);
+      return { ok: true, scene: parsed, issues: this.issues, hints: [] };
+    }
+    return this.apply({ op: "replace_scene", scene: parsed }, "Replace animation");
+  }
+  setReadOnly(readOnly) {
+    if (this.readOnly === readOnly) return;
+    this.readOnly = readOnly;
+    this.notify();
+  }
+  /** Selects a shot (and optionally a command in it); `null` clears. Unknown shots clear. */
+  select(selection) {
+    const shot = selection && this.scene.shots.find((s) => s.id === selection.shot);
+    const next = shot ? { shot: shot.id, ...selection.command !== void 0 && selection.command < shot.run.length ? { command: selection.command } : {} } : null;
+    if (JSON.stringify(next) === JSON.stringify(this.selection)) return;
+    this.selection = next;
+    this.notify();
+  }
+  play() {
+    this.player.play();
+  }
+  pause() {
+    this.player.pause();
+  }
+  toggle() {
+    this.player.toggle();
+  }
+  /** Moves the playhead (ms). */
+  seek(time) {
+    this.player.seek(time);
+  }
+  /** Moves the playhead to the start or end of a shot. Returns false for an unknown shot. */
+  seekShot(id, at = "start") {
+    const shot = compileMotionScene(this.scene).shots.find((s) => s.id === id);
+    if (!shot) return false;
+    this.player.seek(at === "start" ? shot.start : shot.end);
+    return true;
+  }
+  undo() {
+    return this.history.undo();
+  }
+  redo() {
+    return this.history.redo();
+  }
+  /** The scene at `time` (default: the playhead). */
+  frame(time = this.player.currentTime, options = {}) {
+    return motionFrameAt(this.scene, time, options);
+  }
+  /** The scene at `time` (default: the playhead) as SVG. */
+  toSvg(time = this.player.currentTime, options = {}) {
+    return motionFrameToSvg(this.scene, time, options);
+  }
+  /** The scene as a Flair `SvgMotion`. */
+  toFlairMotion(options = {}) {
+    return toFlairSvgMotion(this.scene, options);
+  }
+  /** The scene as a Flair catalog vector effect. */
+  toFlairEffect(options = {}) {
+    return toFlairVectorEffect(this.scene, options);
+  }
+  /** The scene as a Flair `EffectDocument`. */
+  toFlairDocument(options = {}) {
+    return toFlairEffectDocument(this.scene, options);
+  }
+}, _class);
+
+// src/animation-editor/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var WRITE = { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false };
+var WRITE_IDEMPOTENT = { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var DESTRUCTIVE = { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false };
+var object = (properties, required = [], description) => ({
+  type: "object",
+  ...description ? { description } : {},
+  properties,
+  ...required.length ? { required } : {},
+  additionalProperties: false
+});
+var SHOT_ID = { type: "string", minLength: 1, description: 'A shot id from get_animation (e.g. "intro").' };
+var NODE_IDS = { type: "array", items: { type: "string", minLength: 1 }, minItems: 1, description: `Node ids from get_animation's "elements" (a group animates as one).` };
+var MS = (what) => ({ type: "number", minimum: 0, description: `${what} in milliseconds.` });
+var FRACTION = (what) => ({ type: "number", minimum: 0, maximum: 1, description: what });
+var POINT = (what) => object({ x: { type: "number", description: "Document units." }, y: { type: "number", description: "Document units." } }, ["x", "y"], what);
+var EASE = {
+  description: `Easing: a preset (${_chunkXZ4L3R4Kcjs.ANIMATION_EASING_PRESETS.join(", ")}) or { "type": "cubic-bezier", "x1", "y1", "x2", "y2" }. Default: a cubic ease-out for entrances, cubic ease-in-out for moves.`,
+  anyOf: [
+    { type: "string", enum: [..._chunkXZ4L3R4Kcjs.ANIMATION_EASING_PRESETS] },
+    object({ type: { const: "cubic-bezier", description: "Curve kind." }, x1: { type: "number", description: "Out handle x (0\u20131)." }, y1: { type: "number", description: "Out handle y." }, x2: { type: "number", description: "In handle x (0\u20131)." }, y2: { type: "number", description: "In handle y." } }, ["type", "x1", "y1", "x2", "y2"])
+  ]
+};
+var BASE = {
+  targets: NODE_IDS,
+  duration: MS("Length for each target (each type has a default; draw follows the path length)"),
+  delay: MS("Wait before starting (default 0)"),
+  stagger: MS("Start each further target this much later (default 0)"),
+  with: { type: "string", enum: ["after", "previous"], description: '"after" (default) starts when the commands before it finish; "previous" starts together with the command before.' },
+  ease: EASE,
+  note: { type: "string", description: "Why this command is here, in a few words." }
+};
+var command = (type, description, extra = {}, required = []) => object({ type: { const: type, description }, ...BASE, ...extra }, ["type", "targets", ...required], description);
+var MOTION_COMMAND_SCHEMA = {
+  description: `A command (one of ${MOTION_COMMAND_TYPES.join(", ")}). Commands in a shot play one after another unless "with": "previous".`,
+  oneOf: [
+    command("enter", "Brings hidden targets in; they are hidden before this shot.", {
+      style: { type: "string", enum: [...MOTION_ENTER_STYLES], description: "fade (default), pop, grow, slide, or draw (outline drawn on, then the fill fades in)." },
+      direction: { type: "string", enum: [...MOTION_DIRECTIONS], description: "For slide: direction of travel (default up)." },
+      distance: { type: "number", description: "For slide: document units (default 40)." }
+    }),
+    command("exit", "Takes targets out.", {
+      style: { type: "string", enum: [...MOTION_EXIT_STYLES], description: "fade (default), shrink, slide or undraw." },
+      direction: { type: "string", enum: [...MOTION_DIRECTIONS], description: "For slide: direction of travel (default down)." },
+      distance: { type: "number", description: "For slide: document units (default 40)." }
+    }),
+    command("draw", "Draws strokes on (or off) to a fraction of their length.", { to: FRACTION("Fraction drawn at the end (default 1)."), from: FRACTION("Fraction drawn at the start (default: what is drawn now).") }),
+    command("move", "Moves targets by an offset or so their centre lands on a point.", { by: POINT("Offset in document units."), to: POINT("Point (document coordinates) for the centre.") }),
+    command("rotate", "Turns targets about their centre (degrees, clockwise).", { by: { type: "number", description: "Degrees to turn by." }, to: { type: "number", description: "Angle to turn to, in degrees from rest." } }),
+    command("scale", "Scales targets about their centre (1 = rest size).", { to: { description: "A factor, or { x, y } factors.", anyOf: [{ type: "number" }, POINT("Factors per axis.")] } }, ["to"]),
+    command("fade", "Changes opacity.", { to: FRACTION("Opacity at the end (0\u20131).") }, ["to"]),
+    command("style", "Blends solid fill / stroke colours (in OKLab) and stroke width. On a group it changes every path in it.", {
+      fill: { type: "string", description: "CSS colour (hex, rgb(), rgba())." },
+      stroke: { type: "string", description: "CSS colour (hex, rgb(), rgba())." },
+      strokeWidth: { type: "number", minimum: 0, description: "Document units." }
+    }),
+    command("morph", "Morphs each target into the shape (and paint) of another node, which usually stays hidden.", { into: { type: "string", minLength: 1, description: "Id of the node whose shape to take." } }, ["into"]),
+    command("follow", "Moves targets along a path node, centre on the path.", {
+      path: { type: "string", minLength: 1, description: "Id of a path node (it can be hidden)." },
+      rotate: { type: "boolean", description: "Turn with the path (default false)." },
+      from: FRACTION("Where to start along the path (default 0)."),
+      to: FRACTION("Where to end along the path (default 1).")
+    }, ["path"]),
+    command("pulse", "Scales up and back to draw the eye.", { amount: { type: "number", description: "Extra scale at the peak (default 0.15)." }, count: { type: "integer", minimum: 1, description: "Pulses (default 1)." } }),
+    command("shake", "Shakes side to side, settling.", { amount: { type: "number", description: "Document units (default 8)." }, count: { type: "integer", minimum: 1, description: "Shakes (default 3)." } }),
+    command("effect", "Tweens a numeric parameter of a live path effect on the targets (twist angle, wiggle time, zig zag size, trim offset\u2026).", {
+      effect: { type: "string", minLength: 1, description: `Effect id from get_animation's element "effects".` },
+      param: { type: "string", minLength: 1, description: "A numeric parameter of that effect (listed with it)." },
+      to: { type: "number", description: "Value at the end." }
+    }, ["effect", "param", "to"]),
+    object(
+      { type: { const: "wait", description: "Waits." }, duration: MS("How long"), with: BASE.with, note: BASE.note },
+      ["type", "duration"],
+      "Waits before the next command."
+    )
+  ]
+};
+var CAMERA = {
+  description: `Where the camera looks: a rectangle { x, y, width, height } in document units, or { frame: "<node id>", padding } to frame a node (fitted to the artwork's shape). It eases there over "ms" (default 1000); the first shot cuts.`,
+  anyOf: [
+    object({ x: { type: "number", description: "Left." }, y: { type: "number", description: "Top." }, width: { type: "number", exclusiveMinimum: 0, description: "Width." }, height: { type: "number", exclusiveMinimum: 0, description: "Height." }, ease: EASE, ms: MS("Camera move length") }, ["x", "y", "width", "height"]),
+    object({ frame: { type: "string", minLength: 1, description: "Node id to frame." }, padding: { type: "number", description: "Margin around it (default 24)." }, ease: EASE, ms: MS("Camera move length") }, ["frame"])
+  ]
+};
+var SHOT_FIELDS = {
+  label: { type: "string", description: "What happens, in a few words." },
+  camera: CAMERA,
+  run: { type: "array", items: MOTION_COMMAND_SCHEMA, description: "Commands, in order." },
+  hold: MS("Hold after the commands (default 600)")
+};
+var SHOT = object({ id: { type: "string", pattern: "^[A-Za-z0-9_][\\w.-]*$", description: 'Unique shot id, e.g. "intro".' }, ...SHOT_FIELDS }, ["id", "run"], "A shot.");
+var CONTROL = object(
+  {
+    name: { type: "string", pattern: "^[A-Za-z_]\\w*$", description: 'Identifier, e.g. "accent".' },
+    type: { const: "color", description: "Controls are colours." },
+    default: { type: "string", pattern: "^#[0-9a-fA-F]{6}$", description: "A #rrggbb colour the scene uses; the control stands for every use of it." },
+    label: { type: "string", description: "Label in a controls panel." }
+  },
+  ["name", "type", "default"],
+  "A colour parameter of the Flair effect made from the scene."
+);
+var PRESET = object({ name: { type: "string", minLength: 1, description: "Preset name." }, values: { type: "object", additionalProperties: { type: "string" }, description: "Control name \u2192 colour." } }, ["name", "values"], "Named control values.");
+var SETTINGS = {
+  name: { type: "string", minLength: 1, description: 'Short name, e.g. "logo-reveal".' },
+  description: { type: ["string", "null"], description: "What it shows; null clears." },
+  loop: { type: "string", enum: ["none", "loop", "ping-pong"], description: "Playback past the end (default none)." },
+  fps: { type: "number", minimum: 1, maximum: 120, description: "Sampling rate for exports (default 30)." },
+  target: { anyOf: [{ type: "array", items: { type: "number", minimum: 0 }, minItems: 2, maxItems: 2 }, { type: "null" }], description: "Wanted length [min, max] in seconds; null clears." }
+};
+var EDIT_OP = {
+  description: `One edit (${MOTION_EDIT_OPS.filter((o) => o !== "replace_scene" && o !== "set_artwork").join(", ")}), shaped like the tool of the same name with an "op" field.`,
+  oneOf: [
+    object({ op: { const: "set_settings", description: "Like set_animation_settings." }, ...SETTINGS }, ["op"]),
+    object({ op: { const: "insert_shots", description: "Like insert_shots." }, shots: { type: "array", items: SHOT, minItems: 1, description: "Shots to add." }, at: { type: "integer", minimum: 0, description: "Position (default: the end)." } }, ["op", "shots"]),
+    object({ op: { const: "update_shot", description: "Like update_shot." }, shot: SHOT_ID, set: object({ id: SHOT.properties.id, ...SHOT_FIELDS }, [], "Fields to replace."), remove: { type: "array", items: { type: "string", enum: ["label", "camera", "hold"] }, description: "Fields to clear." } }, ["op", "shot"]),
+    object({ op: { const: "delete_shots", description: "Like delete_shots." }, shots: { type: "array", items: SHOT_ID, minItems: 1, description: "Shot ids." } }, ["op", "shots"]),
+    object({ op: { const: "move_shot", description: "Like move_shot." }, shot: SHOT_ID, to: { type: "integer", minimum: 0, description: "New position (0 = first)." } }, ["op", "shot", "to"]),
+    object({ op: { const: "add_commands", description: "Like add_commands." }, shot: SHOT_ID, commands: { type: "array", items: MOTION_COMMAND_SCHEMA, minItems: 1, description: "Commands to add." }, at: { type: "integer", minimum: 0, description: "Index in the shot's run (default: the end)." } }, ["op", "shot", "commands"]),
+    object({ op: { const: "update_command", description: "Like update_command." }, shot: SHOT_ID, command: { type: "integer", minimum: 0, description: "Index in the shot's run." }, set: { type: "object", description: "Command fields to replace." }, remove: { type: "array", items: { type: "string" }, description: "Command fields to clear." } }, ["op", "shot", "command"]),
+    object({ op: { const: "delete_commands", description: "Like delete_commands." }, shot: SHOT_ID, commands: { type: "array", items: { type: "integer", minimum: 0 }, minItems: 1, description: "Indexes in the shot's run." } }, ["op", "shot", "commands"]),
+    object({ op: { const: "set_controls", description: "Like set_controls." }, controls: { type: "array", items: CONTROL, description: "Controls (empty clears)." }, presets: { type: "array", items: PRESET, description: "Presets (empty clears)." } }, ["op", "controls"])
+  ]
+};
+function describeElement(node, ancestors) {
+  const effects = (_nullishCoalesce(node.effects, () => ( []))).map((e) => ({
+    id: e.id,
+    type: e.type,
+    numericParams: Object.fromEntries(Object.entries(e.params).filter(([, v]) => typeof v === "number"))
+  }));
+  return {
+    id: node.id,
+    type: node.type,
+    ...node.name ? { name: node.name } : {},
+    ...ancestors.length ? { parent: ancestors[ancestors.length - 1] } : {},
+    ...node.visible === false ? { hidden: true } : {},
+    ...node.type === "path" && typeof node.fill === "string" ? { fill: node.fill } : {},
+    ...node.type === "path" && typeof node.stroke === "string" ? { stroke: node.stroke } : {},
+    ...node.type === "group" ? { children: node.children.map((c) => c.id) } : {},
+    ...effects.length ? { effects } : {}
+  };
+}
+var round = (n) => Math.round(n * 10) / 10;
+function describeMotionElements(scene) {
+  return [...indexMotionNodes(scene.artwork.nodes).values()].map((e) => ({
+    ...describeElement(e.node, e.ancestors),
+    ...e.bounds ? { bounds: { x: round(e.bounds.x), y: round(e.bounds.y), width: round(e.bounds.width), height: round(e.bounds.height) } } : {}
+  }));
+}
+function describeMotionShots(scene) {
+  const timeline = compileMotionScene(scene);
+  return scene.shots.map((shot, i) => {
+    const t = timeline.shots[i];
+    return {
+      id: shot.id,
+      ...shot.label ? { label: shot.label } : {},
+      start: t.start,
+      end: t.end,
+      ...shot.camera ? { camera: shot.camera } : {},
+      ...shot.hold !== void 0 ? { hold: shot.hold } : {},
+      commands: shot.run.map((c, index) => {
+        const ct = timeline.commands.find((x) => x.shotIndex === i && x.command === index);
+        return { index, ...c, start: ct.start, end: ct.end };
+      })
+    };
+  });
+}
+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}: ${motionIssueLine(i)}`)
+});
+function createAnimationEditorToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const r = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (r) return typeof r === "string" ? r : "This animation is read-only.";
+    return controller.readOnlyReason();
+  };
+  const scene = () => controller.getScene();
+  const outcome = (result, extra = {}) => {
+    if (!result.ok) throw new Error(result.error);
+    const timeline = compileMotionScene(result.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 } : {}
+    };
+  };
+  const apply = (edits, label, extra) => {
+    const result = controller.apply(edits, label);
+    return outcome(result, result.ok && extra ? extra(result.scene) : {});
+  };
+  const getAnimation = {
+    name: "get_animation",
+    title: "Read the animation",
+    description: "Returns the vector animation: its name, artwork size, length (ms), loop mode, the artwork's elements (id, type, name, parent, bounds, solid paints, live effects with their numeric parameters), every shot with its commands and their start/end times, Flair controls, and a summary of issues. Use the ids it returns with the write tools.",
+    inputSchema: object({ includeElements: { type: "boolean", description: "Include the artwork's elements (default true)." } }),
+    annotations: { title: "Read the animation", ...READ },
+    handler: ({ includeElements = true }) => {
+      const s = scene();
+      const reason = readOnlyReason();
+      return {
+        name: s.name,
+        ...s.description ? { description: s.description } : {},
+        artwork: { width: s.artwork.width, height: s.artwork.height },
+        duration: compileMotionScene(s).duration,
+        loop: _nullishCoalesce(s.loop, () => ( "none")),
+        ...s.target ? { target: s.target } : {},
+        ...includeElements ? { elements: describeMotionElements(s) } : {},
+        shots: describeMotionShots(s),
+        ...s.controls ? { controls: s.controls } : {},
+        ...s.presets ? { presets: s.presets } : {},
+        issues: issueSummary(controller.getState().issues),
+        ...reason ? { readOnly: reason } : {}
+      };
+    }
+  };
+  const getShot = {
+    name: "get_shot",
+    title: "Read one shot",
+    description: "Returns one shot as stored (id, label, camera, run, hold) with its start/end and each command's start/end in ms.",
+    inputSchema: object({ shot: SHOT_ID }, ["shot"]),
+    annotations: { title: "Read one shot", ...READ },
+    handler: ({ shot }) => {
+      const found = describeMotionShots(scene()).find((s) => s.id === shot);
+      if (!found) throw new Error(`There is no shot "${shot}"; the shots are ${scene().shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
+      return found;
+    }
+  };
+  const findElements = {
+    name: "find_animation_elements",
+    title: "Find artwork elements",
+    description: "Finds artwork elements whose id or name contains the text (case-insensitive). Returns their id, type, name, parent, bounds, paints and live effects.",
+    inputSchema: object({ query: { type: "string", minLength: 1, description: "Text to look for in ids and names." }, limit: { type: "integer", minimum: 1, maximum: 200, description: "Most results (default 20)." } }, ["query"]),
+    annotations: { title: "Find artwork elements", ...READ },
+    handler: ({ query, limit = 20 }) => {
+      const q = String(query).toLowerCase();
+      const all = describeMotionElements(scene());
+      const elements = all.filter((e) => e.id.toLowerCase().includes(q) || "name" in e && String(e.name).toLowerCase().includes(q));
+      return { elements: elements.slice(0, limit), total: elements.length };
+    }
+  };
+  const checkAnimation = {
+    name: "check_animation",
+    title: "Check the animation",
+    description: "Lists the animation's problems: each with a stable code (unknown-target, overlap, out-of-frame, too-fast, enter-visible\u2026), severity (error / warning / note), the shot and command index it is in, the node ids it is about, measured vs needed values, and a message saying how to fix it.",
+    inputSchema: object({}),
+    annotations: { title: "Check the animation", ...READ },
+    handler: () => {
+      const issues = controller.getState().issues;
+      return { ...issueSummary(issues), issues };
+    }
+  };
+  const renderFrame = {
+    name: "render_animation_frame",
+    title: "Render a frame",
+    description: 'Draws the animation at one moment without changing it, to check it: standalone SVG by default, or a PNG image (format "png") when the host can rasterize. Give a time in ms, or a shot and where in it.',
+    inputSchema: object({
+      time: MS("Time from the start"),
+      shot: { ...SHOT_ID, description: 'Render a moment of this shot instead of "time".' },
+      at: { type: "string", enum: ["start", "middle", "end"], description: "With shot: which moment (default end: everything drawn, before the next shot)." },
+      format: { type: "string", enum: ["svg", "png"], description: "svg (default) or png (only when the host supports it)." }
+    }),
+    annotations: { title: "Render a frame", ...READ },
+    handler: async ({ time, shot, at = "end", format = "svg" }) => {
+      const s = scene();
+      let t = _nullishCoalesce(time, () => ( controller.getState().time));
+      if (shot !== void 0) {
+        const timing = compileMotionScene(s).shots.find((x) => x.id === shot);
+        if (!timing) throw new Error(`There is no shot "${shot}"; the shots are ${s.shots.map((x) => `"${x.id}"`).join(", ") || "none yet"}.`);
+        t = at === "start" ? timing.start : at === "middle" ? (timing.commandsStart + timing.commandsEnd) / 2 : Math.max(timing.start, timing.end - 1);
+      }
+      const svg = controller.toSvg(t, { pretty: false });
+      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 });
+        return { content: [{ type: "image", data: image.data, mimeType: image.mimeType }] };
+      }
+      return { time: t, svg };
+    }
+  };
+  const exportFlairMotion = {
+    name: "export_flair_motion",
+    title: "Export as Flair vector motion",
+    description: "Returns the animation as a Flair SvgMotion ({ svg, animate }) that Flair's SvgPlayer plays, plus its hold, how many changes were sampled into linear steps, and notes on anything not carried over.",
+    inputSchema: object({ fps: { type: "number", minimum: 1, maximum: 120, description: "Sampling rate for changes Flair cannot express exactly (default: the scene's fps, else 30)." } }),
+    annotations: { title: "Export as Flair vector motion", ...READ },
+    handler: ({ fps }) => controller.toFlairMotion(fps ? { fps } : {})
+  };
+  const exportFlairEffect = {
+    name: "export_flair_effect",
+    title: "Export as a Flair effect",
+    description: `Returns the animation as a Flair catalog vector effect: { kind: "vector", id, name, description, category, tags, motion, hold, presets }, with each colour control declared as a {{name: color}} placeholder. Add it to a Flair catalog or load it in Flair's effect editor.`,
+    inputSchema: object({
+      id: { type: "string", pattern: "^[a-z0-9]+(-[a-z0-9]+)*$", description: "Kebab-case id (default: from the scene's name)." },
+      name: { type: "string", minLength: 1, description: "Display name (default: the scene's name)." },
+      description: { type: "string", description: "One sentence (default: the scene's description)." },
+      category: { type: "string", minLength: 1, description: "Flair catalog category, e.g. icon, loader, ui, data, text, morph (default icon)." },
+      tags: { type: "array", items: { type: "string" }, description: "Search tags (default none)." }
+    }),
+    annotations: { title: "Export as a Flair effect", ...READ },
+    handler: (args) => controller.toFlairEffect(args)
+  };
+  const setArtworkSvg = {
+    name: "set_animation_artwork_svg",
+    title: "Replace the artwork with SVG",
+    description: "Replaces the artwork with an SVG (paths, shapes, groups, gradients; one undo step). Give every element you will animate an id: commands target ids. Shots that name ids the new artwork lacks are refused. Returns the elements.",
+    inputSchema: object({ svg: { type: "string", minLength: 1, description: "A standalone <svg> with a viewBox." } }, ["svg"]),
+    annotations: { title: "Replace the artwork with SVG", ...DESTRUCTIVE },
+    handler: ({ svg }) => {
+      let artwork;
+      try {
+        artwork = _chunkXCXQDPIDcjs.parseVectorSvg.call(void 0, svg);
+      } catch (error) {
+        throw new Error(`The SVG could not be read: ${error.message}. Nothing was changed.`);
+      }
+      return apply({ op: "set_artwork", artwork }, "Replace artwork", (s) => ({ elements: describeMotionElements(s) }));
+    }
+  };
+  const insertShots = {
+    name: "insert_shots",
+    title: "Add shots",
+    description: "Adds shots (one undo step) at a position (default: the end). Returns every shot's new timing and any issues.",
+    inputSchema: object({ shots: { type: "array", items: SHOT, minItems: 1, description: "Shots to add." }, at: { type: "integer", minimum: 0, description: "Position, 0 = first (default: the end)." } }, ["shots"]),
+    annotations: { title: "Add shots", ...WRITE },
+    handler: ({ shots, at }) => apply({ op: "insert_shots", shots, at }, "Add shots", () => ({ added: shots.map((s) => s.id) }))
+  };
+  const updateShot = {
+    name: "update_shot",
+    title: "Change a shot",
+    description: 'Replaces the fields of one shot given in "set" (label, camera, run, hold, id) and clears those in "remove". Returns the new timing and issues.',
+    inputSchema: object(
+      {
+        shot: SHOT_ID,
+        set: object({ id: SHOT.properties.id, ...SHOT_FIELDS }, [], "Fields to replace."),
+        remove: { type: "array", items: { type: "string", enum: ["label", "camera", "hold"] }, description: "Fields to clear." }
+      },
+      ["shot"]
+    ),
+    annotations: { title: "Change a shot", ...WRITE_IDEMPOTENT },
+    handler: ({ shot, set, remove }) => apply({ op: "update_shot", shot, set, remove }, "Change shot")
+  };
+  const deleteShots = {
+    name: "delete_shots",
+    title: "Delete shots",
+    description: "Removes shots by id (one undo step). Returns the remaining timing.",
+    inputSchema: object({ shots: { type: "array", items: SHOT_ID, minItems: 1, description: "Shot ids." } }, ["shots"]),
+    annotations: { title: "Delete shots", ...DESTRUCTIVE },
+    handler: ({ shots }) => apply({ op: "delete_shots", shots }, "Delete shots")
+  };
+  const moveShot = {
+    name: "move_shot",
+    title: "Reorder a shot",
+    description: "Moves a shot to a new position (0 = first). Returns the new timing.",
+    inputSchema: object({ shot: SHOT_ID, to: { type: "integer", minimum: 0, description: "New position, 0 = first." } }, ["shot", "to"]),
+    annotations: { title: "Reorder a shot", ...WRITE_IDEMPOTENT },
+    handler: ({ shot, to }) => apply({ op: "move_shot", shot, to }, "Move shot")
+  };
+  const addCommands = {
+    name: "add_commands",
+    title: "Add commands to a shot",
+    description: "Adds commands to a shot's run (one undo step), at an index (default: the end). Returns the indexes they got, their timing and any issues.",
+    inputSchema: object({ shot: SHOT_ID, commands: { type: "array", items: MOTION_COMMAND_SCHEMA, minItems: 1, description: "Commands to add." }, at: { type: "integer", minimum: 0, description: "Index in the run (default: the end)." } }, ["shot", "commands"]),
+    annotations: { title: "Add commands to a shot", ...WRITE },
+    handler: ({ shot, commands, at }) => {
+      const before = _nullishCoalesce(_optionalChain([scene, 'call', _46 => _46(), 'access', _47 => _47.shots, 'access', _48 => _48.find, 'call', _49 => _49((s) => s.id === shot), 'optionalAccess', _50 => _50.run, 'access', _51 => _51.length]), () => ( 0));
+      const first = _nullishCoalesce(at, () => ( before));
+      return apply({ op: "add_commands", shot, commands, at }, "Add commands", (s) => {
+        const shots = describeMotionShots(s);
+        const added = shots.find((x) => x.id === shot).commands.slice(first, first + commands.length);
+        return { added: added.map((c) => ({ index: c.index, type: c.type, start: c.start, end: c.end })) };
+      });
+    }
+  };
+  const updateCommand = {
+    name: "update_command",
+    title: "Change a command",
+    description: 'Replaces fields of one command (by shot and index) given in "set" and clears those in "remove". Returns the command as it now stands with its timing.',
+    inputSchema: object(
+      {
+        shot: SHOT_ID,
+        command: { type: "integer", minimum: 0, description: "Index in the shot's run (from get_animation)." },
+        set: { type: "object", description: "Command fields to replace (see add_commands for each type's fields)." },
+        remove: { type: "array", items: { type: "string" }, description: 'Optional fields to clear (e.g. "delay").' }
+      },
+      ["shot", "command"]
+    ),
+    annotations: { title: "Change a command", ...WRITE_IDEMPOTENT },
+    handler: ({ shot, command: command2, set, remove }) => apply({ op: "update_command", shot, command: command2, set, remove }, "Change command", (s) => ({ command: describeMotionShots(s).find((x) => x.id === shot).commands[command2] }))
+  };
+  const deleteCommands = {
+    name: "delete_commands",
+    title: "Delete commands",
+    description: "Removes commands from a shot by index (one undo step). Later commands move up. Returns the new timing.",
+    inputSchema: object({ shot: SHOT_ID, commands: { type: "array", items: { type: "integer", minimum: 0 }, minItems: 1, description: "Indexes in the shot's run." } }, ["shot", "commands"]),
+    annotations: { title: "Delete commands", ...DESTRUCTIVE },
+    handler: ({ shot, commands }) => apply({ op: "delete_commands", shot, commands }, "Delete commands")
+  };
+  const setSettings = {
+    name: "set_animation_settings",
+    title: "Change animation settings",
+    description: "Sets the name, description, loop mode, export frame rate or target length. Returns the timing.",
+    inputSchema: object(SETTINGS),
+    annotations: { title: "Change animation settings", ...WRITE_IDEMPOTENT },
+    handler: (args) => apply({ op: "set_settings", ...args }, "Change settings")
+  };
+  const setControls = {
+    name: "set_animation_controls",
+    title: "Set Flair controls",
+    description: "Sets the colour controls (and presets) a Flair effect made from this animation exposes: each control stands for every use of its default colour. Replaces the existing controls; an empty list clears them. Returns the issues.",
+    inputSchema: object({ controls: { type: "array", items: CONTROL, description: "Controls (empty clears)." }, presets: { type: "array", items: PRESET, description: "Presets (empty clears; omit to keep)." } }, ["controls"]),
+    annotations: { title: "Set Flair controls", ...WRITE_IDEMPOTENT },
+    handler: ({ controls, presets }) => apply({ op: "set_controls", controls, presets }, "Set controls")
+  };
+  const editAnimation = {
+    name: "edit_animation",
+    title: "Make several edits at once",
+    description: 'Applies several edits in order as one undo step, all or nothing: if one fails, nothing changes and the error names the op ("op 2 (add_commands): \u2026"). With dry_run it only reports the timing and issues the edits would give.',
+    inputSchema: object({ ops: { type: "array", items: EDIT_OP, minItems: 1, description: "Edits, applied in order." }, dry_run: { type: "boolean", description: "Check without applying (default false)." } }, ["ops"]),
+    annotations: { title: "Make several edits at once", ...WRITE },
+    handler: ({ ops, dry_run = false }) => {
+      const result = controller.apply(ops, "Edit animation", { dryRun: dry_run });
+      return outcome(result, dry_run ? { dry_run: true, hint: "Nothing was applied; call again without dry_run to apply." } : {});
+    }
+  };
+  const writeAnimation = {
+    name: "write_animation",
+    title: "Replace the animation's shots",
+    description: "Replaces every shot (and optionally the settings and controls), keeping the artwork, as one undo step. For small changes prefer the per-operation tools. Returns the timing and issues.",
+    inputSchema: object({ shots: { type: "array", items: SHOT, description: "All shots, in order." }, ...SETTINGS, controls: { type: "array", items: CONTROL, description: "Colour controls." }, presets: { type: "array", items: PRESET, description: "Presets." } }, ["shots"]),
+    annotations: { title: "Replace the animation's shots", ...DESTRUCTIVE },
+    handler: ({ shots, controls, presets, ...settings }) => {
+      const current = scene();
+      const next = { ...current, shots };
+      const edits = [{ op: "replace_scene", scene: next }];
+      if (Object.keys(settings).length) edits.push({ op: "set_settings", ...settings });
+      if (controls) edits.push({ op: "set_controls", controls, presets });
+      return apply(edits, "Replace animation");
+    }
+  };
+  const seekAnimation = {
+    name: "seek_animation",
+    title: "Show a moment",
+    description: "Moves the playhead the person sees to a time or the start of a shot, and plays or pauses. Does not change the animation. Returns the playhead time and shot.",
+    inputSchema: object({ time: MS("Time from the start"), shot: { ...SHOT_ID, description: 'Go to the start of this shot instead of "time".' }, play: { type: "boolean", description: "true plays from there, false pauses (default: leave as is)." } }),
+    annotations: { title: "Show a moment", ...WRITE_IDEMPOTENT },
+    handler: ({ time, shot, play }) => {
+      if (shot !== void 0 && !controller.seekShot(shot)) throw new Error(`There is no shot "${shot}"; the shots are ${scene().shots.map((s) => `"${s.id}"`).join(", ") || "none yet"}.`);
+      if (shot === void 0 && time !== void 0) controller.seek(time);
+      if (play === true) controller.play();
+      if (play === false) controller.pause();
+      const state = controller.getState();
+      return { time: state.time, shot: state.currentShot, playing: state.playing };
+    }
+  };
+  const undo = {
+    name: "undo_animation",
+    title: "Undo an animation edit",
+    description: "Undoes the last edit. Returns whether something was undone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Undo an animation edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().undoLabel;
+      const undone = controller.undo();
+      return { undone, ...undone ? { label } : {} };
+    }
+  };
+  const redo = {
+    name: "redo_animation",
+    title: "Redo an animation edit",
+    description: "Redoes the last undone edit. Returns whether something was redone and its label.",
+    inputSchema: object({}),
+    annotations: { title: "Redo an animation edit", ...WRITE },
+    handler: () => {
+      const label = controller.getState().redoLabel;
+      const redone = controller.redo();
+      return { redone, ...redone ? { label } : {} };
+    }
+  };
+  const reads = [getAnimation, getShot, findElements, checkAnimation, renderFrame, exportFlairMotion, exportFlairEffect, seekAnimation];
+  const writes = [setArtworkSvg, insertShots, updateShot, deleteShots, moveShot, addCommands, updateCommand, deleteCommands, setSettings, setControls, editAnimation, writeAnimation, undo, redo];
+  return {
+    id: _nullishCoalesce(options.id, () => ( "animation")),
+    namespace: options.namespace,
+    tools: () => readOnlyReason() ? reads : [...reads, ...writes],
+    subscribe: (notify) => {
+      let last = readOnlyReason();
+      return controller.subscribe(() => {
+        const now = readOnlyReason();
+        if (now !== last) {
+          last = now;
+          notify();
+        }
+      });
+    }
+  };
+}
+
+// src/animation-editor/instructions.ts
+var ANIMATION_EDITOR_AGENT_INSTRUCTIONS = `You animate vector artwork. A scene is artwork (vector paths and groups, each with an id) plus shots.
+
+How it plays
+- Shots play in order. A shot optionally moves the camera, plays its commands, then holds (default 600 ms).
+- Commands in a shot play one after another; give "with": "previous" to start one together with the command before, "delay" to wait, "stagger" to offset several targets.
+- Timing comes from the content: each command has a default length (enter 600 ms, move 700 ms, draw follows the path length). Only set "duration" to change the pace.
+- Anything that enters later is hidden until it enters. Things that never enter are visible from the start.
+- Every frame is a pure function of time: the same scene always plays the same frames.
+
+Commands
+- enter (fade, pop, grow, slide, draw) and exit (fade, shrink, slide, undraw) bring things in and out.
+- draw draws strokes on to a fraction; move, rotate, scale and fade change the pose (about the centre); style blends solid colours and stroke width.
+- morph turns a shape into another node's shape (keep the target hidden); follow moves along a path node; pulse and shake draw the eye.
+- effect tweens a numeric parameter of a live path effect already on the node (twist angle, wiggle time, zig zag size).
+
+Working method
+1. get_animation to learn the element ids (set_animation_artwork_svg first if there is no artwork: give every element you will animate an id).
+2. Plan a few shots, each one idea. Add them with insert_shots, or edit_animation to make several edits as one step (dry_run first when unsure).
+3. check_animation and fix every error and warning; render_animation_frame (shot + "end") to look at the result.
+4. To make a reusable Flair effect, set_animation_controls (colour controls stand for every use of their default colour) and export_flair_effect.
+
+Keep motion purposeful: one thing moving at a time reads best, ease-out for arrivals, ease-in for exits, and hold long enough to see each result.`;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ANIMATION_EDITOR_AGENT_INSTRUCTIONS = ANIMATION_EDITOR_AGENT_INSTRUCTIONS; exports.AnimationEditorController = AnimationEditorController; exports.FLAIR_EASES = FLAIR_EASES; exports.MOTION_CAMERA_MS = MOTION_CAMERA_MS; exports.MOTION_COMMAND_SCHEMA = MOTION_COMMAND_SCHEMA; exports.MOTION_COMMAND_TYPES = MOTION_COMMAND_TYPES; 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_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_ISSUE_CODES = MOTION_ISSUE_CODES; exports.MOTION_MIN_CHANGE_MS = MOTION_MIN_CHANGE_MS; exports.MotionSceneFormatError = MotionSceneFormatError; exports.activeSegment = activeSegment; exports.applyMotionControlValues = applyMotionControlValues; exports.applyMotionEdits = applyMotionEdits; exports.checkMotionScene = checkMotionScene; exports.commandShapeProblems = commandShapeProblems; exports.compileMotionScene = compileMotionScene; exports.createAnimationEditorToolProvider = createAnimationEditorToolProvider; exports.createMotionScene = createMotionScene; exports.describeMotionElements = describeMotionElements; exports.describeMotionShots = describeMotionShots; exports.fitMotionRect = fitMotionRect; exports.flairEaseFor = flairEaseFor; exports.freshShotId = freshShotId; exports.indexMotionNodes = indexMotionNodes; exports.interpolateMotionValue = interpolateMotionValue; exports.isMotionCommand = isMotionCommand; exports.isMotionShot = isMotionShot; exports.motionCommandDuration = motionCommandDuration; exports.motionFrameAt = motionFrameAt; exports.motionFrameToSvg = motionFrameToSvg; exports.motionIssue = motionIssue; exports.motionIssueKey = motionIssueKey; exports.motionIssueLine = motionIssueLine; exports.motionNodeOffset = motionNodeOffset; exports.motionPathLength = motionPathLength; exports.motionRestValue = motionRestValue; exports.motionSceneShapeProblems = motionSceneShapeProblems; exports.motionSceneToJson = motionSceneToJson; exports.motionShotAt = motionShotAt; exports.motionTrackKey = motionTrackKey; exports.namedWithSuggestion = namedWithSuggestion; exports.parseMotionScene = parseMotionScene; exports.resolveMotionCamera = resolveMotionCamera; exports.segmentProgress = segmentProgress; exports.segmentValue = segmentValue; exports.shotShapeProblems = shotShapeProblems; exports.suggestName = suggestName; exports.toFlairEffectDocument = toFlairEffectDocument; exports.toFlairSvgMotion = toFlairSvgMotion; exports.toFlairVectorEffect = toFlairVectorEffect; exports.trackValue = trackValue; exports.withViewBox = withViewBox;
+//# sourceMappingURL=index.cjs.map