@pixerate/editor 0.124.0 → 0.125.0

package/dist/animation-editor/index.js

@@ -1,6 +1,6 @@
 import {
   createVectorMorph
-} from "../chunk-NGYD3AMN.js";
+} from "../chunk-MPQAO33O.js";
 import {
   MOTION_ISSUE_CODES,
   motionIssue,
@@ -31,7 +31,16 @@ import {
   vectorNodeBounds,
   vectorPathWorldBezier,
   vectorTextHasOutlines
-} from "../chunk-5EO2IXQE.js";
+} from "../chunk-FPRIUR4T.js";
+import {
+  createEffectToolProvider
+} from "../chunk-XZWOLXWA.js";
+import {
+  EffectUnsupportedError,
+  EffectsSlot,
+  isEffectError,
+  resolveEffectValues
+} from "../chunk-TGKT5QAB.js";
 import {
   bezierPathLength,
   bezierPathPointAtLength,
@@ -40,6 +49,7 @@ import {
   transformBezierPath
 } from "../chunk-FG274FYT.js";
 import "../chunk-GLWZXQ4Q.js";
+import "../chunk-4FX5ACVG.js";
 import {
   readZip
 } from "../chunk-33AHNSEB.js";
@@ -166,7 +176,7 @@ ${problems.map((p) => `- ${p}`).join("\n")}`);
 var SCENE_KEYS = ["version", "name", "description", "artwork", "shots", "clips", "drivers", "motionBlur", "loop", "trigger", "fps", "steps", "beat", "narration", "target", "controls", "presets"];
 var SHOT_KEYS = ["id", "label", "camera", "at", "run", "hold", "speed"];
 var CAMERA_KEYS = ["x", "y", "width", "height", "frame", "padding", "ease", "ms", "geometric"];
-var BASE_KEYS = ["type", "targets", "duration", "delay", "stagger", "with", "ease", "note", "repeat", "repeatMode", "steps", "split", "cascade"];
+var BASE_KEYS = ["type", "targets", "duration", "delay", "stagger", "with", "ease", "note", "repeat", "repeatMode", "steps", "split", "cascade", "source"];
 var DRAW_ORDER_KEYS = ["order", "pace", "align", "sortBy", "origin"];
 var COMMAND_KEYS = {
   enter: [...BASE_KEYS, ...DRAW_ORDER_KEYS, "style", "direction", "distance", "scale", "shape", "orientation"],
@@ -224,6 +234,11 @@ function commandShapeProblems(command3, where) {
     if (command3.origin !== void 0 && !isPoint(command3.origin)) p(`"origin" must be { "x": number, "y": number } (document units).`);
   }
   if (command3.note !== void 0 && typeof command3.note !== "string") p(`"note" must be a string.`);
+  if (command3.source !== void 0) {
+    const src = command3.source;
+    if (!isObject(src) || typeof src.instance !== "string" || !src.instance || typeof src.effect !== "string" || !src.effect) p(`"source" must be { instance, effect, provider?, name?, values? } (set by applyMotionEffect).`);
+    else unknownKeys(src, ["instance", "effect", "provider", "name", "values"], `${where} (${type}) source`, problems);
+  }
   if (type === "wait") {
     if (!isNum(command3.duration) || command3.duration < 0) p(`"duration" must be a number of milliseconds \u2265 0.`);
     return problems;
@@ -3484,11 +3499,103 @@ ${problems.join("\n")}`);
   return { scene, notes: [...new Set(ctx.notes)], issues: checkMotionScene(scene), slides: slidePaths.length };
 }
 
+// src/animation-editor/effects.ts
+var sourceOf = (c) => c.source;
+function motionSceneEffects(scene) {
+  const out = /* @__PURE__ */ new Map();
+  const groups = new Set(scene.artwork.nodes.filter((n) => n.type === "group").map((n) => n.id));
+  for (const shot of scene.shots) {
+    for (const c of shot.run) {
+      const s = sourceOf(c);
+      if (!s) continue;
+      let e = out.get(s.instance);
+      if (!e) {
+        const vector = groups.has(s.instance);
+        e = { instance: s.instance, effect: s.effect, ...s.provider ? { provider: s.provider } : {}, ...s.name ? { name: s.name } : {}, values: { ...s.values ?? {} }, kind: vector ? "vector" : "motion", targets: vector ? [s.instance] : [], shots: [], ...vector ? { group: s.instance } : {} };
+        out.set(s.instance, e);
+      }
+      if (!e.shots.includes(shot.id)) e.shots.push(shot.id);
+      if (e.kind === "motion" && "targets" in c) {
+        for (const t of c.targets) if (!e.targets.includes(t)) e.targets.push(t);
+      }
+    }
+  }
+  return [...out.values()];
+}
+function nextMotionEffectInstance(scene) {
+  const used = /* @__PURE__ */ new Set([...motionSceneEffects(scene).map((e) => e.instance), ...scene.shots.map((s) => s.id)]);
+  const walk = (nodes) => nodes.forEach((n) => (used.add(n.id), n.type === "group" && walk(n.children)));
+  walk(scene.artwork.nodes);
+  for (let i = 1; ; i++) if (!used.has(`fx${i}`)) return `fx${i}`;
+}
+var motionArtworkSvg = (artwork) => vectorDocumentToSvg(artwork);
+var tag = (commands, source) => commands.map((c) => c.type === "wait" ? c : { ...c, source });
+function motionCommandsFromEffect(artwork, motion, source) {
+  const imported = fromFlairSvgMotion({ svg: motionArtworkSvg(artwork), animate: [...motion.animate ?? []] });
+  const commands = [];
+  imported.scene.shots.forEach((shot, i) => {
+    shot.run.forEach((c, j) => commands.push(i > 0 && j === 0 ? { ...c, with: "after" } : c));
+  });
+  return { commands: tag(commands, source), notes: imported.notes };
+}
+function prefixed(nodes, shots, prefix) {
+  const map = /* @__PURE__ */ new Map();
+  const rename = (list) => list.map((n) => {
+    map.set(n.id, prefix + n.id);
+    const next = { ...n, id: prefix + n.id };
+    if (next.type === "group") next.children = rename(n.children);
+    return next;
+  });
+  const out = rename(nodes);
+  const id = (v) => typeof v === "string" && map.has(v) ? map.get(v) : v;
+  const remapped = shots.map((s) => ({
+    ...s,
+    run: s.run.map((c) => {
+      const next = { ...c };
+      if (Array.isArray(next.targets)) next.targets = next.targets.map((t) => id(t));
+      for (const k of ["path", "into"]) if (k in next) next[k] = id(next[k]);
+      return next;
+    })
+  }));
+  return { nodes: out, shots: remapped };
+}
+function motionPartsFromVectorEffect(artwork, motion, source, box = { x: 0, y: 0, width: artwork.width, height: artwork.height }) {
+  const imported = fromFlairSvgMotion({ svg: motion.svg, animate: [...motion.animate ?? []] }, { hold: 0 });
+  const art = imported.scene.artwork;
+  const prefix = `${source.instance}-`;
+  const { nodes, shots } = prefixed(art.nodes, imported.scene.shots, prefix);
+  const k = Math.min(box.width / art.width, box.height / art.height);
+  const dx = box.x + (box.width - art.width * k) / 2;
+  const dy = box.y + (box.height - art.height * k) / 2;
+  const group = { type: "group", id: source.instance, name: source.name ?? source.effect, children: nodes, transform: [k, 0, 0, k, dx, dy] };
+  const tagged = shots.map((s, i) => ({ ...s, id: i === 0 ? source.instance + "-shot" : `${source.instance}-shot-${i + 1}`, run: tag(s.run, source) }));
+  return { group, shots: tagged.map((s) => s.hold === 0 ? (({ hold: _h, ...rest }) => rest)(s) : s), notes: imported.notes };
+}
+function withoutMotionEffect(scene, instance) {
+  let place = null;
+  const removedShots = [];
+  const shots = [];
+  for (const shot of scene.shots) {
+    const run = shot.run.filter((c, i) => {
+      const mine = sourceOf(c)?.instance === instance;
+      if (mine && !place) place = { shot: shot.id, index: i };
+      return !mine;
+    });
+    if (run.length === shot.run.length) shots.push(shot);
+    else if (run.length === 0) removedShots.push(shot.id);
+    else shots.push({ ...shot, run });
+  }
+  const artwork = { ...scene.artwork, nodes: scene.artwork.nodes.filter((n) => n.id !== instance) };
+  return { scene: { ...scene, shots, artwork }, place, removedShots };
+}
+
 // src/animation-editor/controller.ts
 var BLANK = { width: 800, height: 450, background: "#ffffff", nodes: [] };
 var AnimationEditorController = class {
   history;
   player;
+  /** The effects provider slot (see `setEffectsProvider`). */
+  effects = new EffectsSlot();
   scene;
   issues;
   selection = null;
@@ -3506,6 +3613,7 @@ var AnimationEditorController = class {
     this.issues = checkMotionScene(this.scene);
     this.readOnly = options.readOnly ?? false;
     this.onChange = options.onChange;
+    if (options.effects) this.effects.set(options.effects);
     this.player = new AnimationPlayer({ clock: options.clock, duration: () => compileMotionScene(this.scene).duration, loop: this.scene.loop ?? "none" });
     this.state = this.computeState();
     this.connect();
@@ -3516,7 +3624,8 @@ var AnimationEditorController = class {
       this.player.subscribe(() => this.notify()),
       this.history.subscribe(() => {
         if (!this.applying) this.notify();
-      })
+      }),
+      this.effects.subscribe(() => this.notify())
     );
   }
   /**
@@ -3559,7 +3668,8 @@ var AnimationEditorController = class {
       canRedo: h.canRedo,
       undoLabel: h.undoName,
       redoLabel: h.redoName,
-      revision: this.revision
+      revision: this.revision,
+      effectsProvider: this.effects.provider
     };
   }
   notify() {
@@ -3592,7 +3702,7 @@ var AnimationEditorController = class {
     this.notify();
     this.onChange?.(scene);
   }
-  commit(label, next) {
+  commit(label, next, merge) {
     const before = this.scene;
     this.error = null;
     if (next === before) {
@@ -3606,7 +3716,8 @@ var AnimationEditorController = class {
       undo: () => this.setScene(before),
       redo: () => this.setScene(next)
     };
-    this.history.execute(command3);
+    if (merge) this.history.executeMerged(command3, { key: merge });
+    else this.history.execute(command3);
   }
   refuse(message) {
     this.error = message;
@@ -3626,13 +3737,155 @@ var AnimationEditorController = class {
     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);
+    if (!options.dryRun) this.commit(label, result.scene, options.merge);
     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);
   }
+  // ---------------------------------------------------------------------------------------
+  // Effects
+  // ---------------------------------------------------------------------------------------
+  /** The registered effects provider, or `null`. */
+  get effectsProvider() {
+    return this.effects.provider;
+  }
+  /** Registers (or with `null` removes) the effects provider. Not an edit: no undo step. */
+  setEffectsProvider(provider) {
+    this.effects.set(provider);
+  }
+  /** Registers `provider` and returns a function that removes it again (if it is still the one set). */
+  useEffects(provider) {
+    return this.effects.use(provider);
+  }
+  /** The provider effects applied in the scene. */
+  appliedEffects() {
+    return motionSceneEffects(this.scene);
+  }
+  async effectEdit(work, merge) {
+    const reason = this.readOnlyReason();
+    if (reason) return this.refuse(reason);
+    let plan;
+    try {
+      plan = await work();
+    } catch (error) {
+      if (isEffectError(error) || error instanceof Error) return this.refuse(error.message);
+      throw error;
+    }
+    const r = this.apply({ op: "replace_scene", scene: plan.scene }, plan.label, { merge });
+    if (!r.ok) return r;
+    const effect = motionSceneEffects(this.scene).find((e) => e.instance === plan.instance);
+    if (!effect) return this.refuse("The effect made no changes the scene can play.");
+    return { ok: true, effect, notes: plan.notes };
+  }
+  async describeFor(effect, kinds) {
+    const provider = this.effects.require();
+    if (!provider.applyVectorEffect) throw new EffectUnsupportedError(`${provider.name} has no vector or motion effects.`);
+    const d = await provider.describe(effect);
+    if (!kinds.includes(d.kind)) {
+      const hint = d.kind === "motion" ? "apply it to nodes with apply_effect" : d.kind === "vector" ? "add it with add_vector_effect" : "it draws pixels, which scenes cannot hold";
+      throw new EffectUnsupportedError(`"${d.id}" (${d.name}) is a ${d.kind} effect: ${hint}.`, d.id);
+    }
+    return d;
+  }
+  knownNodes(ids) {
+    const all = /* @__PURE__ */ new Set();
+    const walk = (nodes) => nodes.forEach((n) => (all.add(n.id), n.type === "group" && walk(n.children)));
+    walk(this.scene.artwork.nodes);
+    const missing = ids.filter((id) => !all.has(id));
+    if (missing.length) throw new Error(`The artwork has no node ${missing.map((m) => `"${m}"`).join(", ")}; get_animation lists the node ids.`);
+    if (!ids.length) throw new Error("Give at least one node to animate.");
+  }
+  /**
+   * Applies a provider motion effect to artwork nodes: the provider animates them and the changes
+   * become commands, in a new shot (default) or added to the end of `shot`. One undo step.
+   * Returns the applied effect (its `instance` id changes or removes it).
+   */
+  applyMotionEffect(effect, targets, options = {}) {
+    return this.effectEdit(async () => {
+      this.knownNodes(targets);
+      const d = await this.describeFor(effect, ["motion"]);
+      const values = resolveEffectValues(d, options.values);
+      const instance = options.instance ?? nextMotionEffectInstance(this.scene);
+      const motion = await this.effects.require().applyVectorEffect(d.id, { svg: motionArtworkSvg(this.scene.artwork), nodeIds: [...targets] }, values);
+      const source = { instance, effect: d.id, provider: this.effects.require().id, name: d.name, values };
+      const { commands, notes } = motionCommandsFromEffect(this.scene.artwork, motion, source);
+      if (!commands.length) throw new Error(`"${d.name}" made no changes the scene can play${notes.length ? `: ${notes.join(" ")}` : ""}.`);
+      let shots = this.scene.shots;
+      if (options.shot) {
+        if (!shots.some((s) => s.id === options.shot)) throw new Error(`There is no shot "${options.shot}"; the shots are ${shots.map((s) => `"${s.id}"`).join(", ")}.`);
+        shots = shots.map((s) => s.id === options.shot ? { ...s, run: [...s.run, ...commands] } : s);
+      } else shots = [...shots, { id: instance, label: d.name, run: commands }];
+      return { scene: { ...this.scene, shots }, label: `Apply ${d.name}`, instance, notes };
+    });
+  }
+  /**
+   * Adds a provider vector effect (one with its own picture: a lower third, a loader): its SVG as
+   * an artwork group (id: the instance) fitted into `box` (default the whole artwork), and its
+   * motion as shots after the last one. One undo step.
+   */
+  addVectorEffect(effect, options = {}) {
+    return this.effectEdit(async () => {
+      const d = await this.describeFor(effect, ["vector"]);
+      const values = resolveEffectValues(d, options.values);
+      const instance = options.instance ?? nextMotionEffectInstance(this.scene);
+      const motion = await this.effects.require().applyVectorEffect(d.id, motionArtworkSvg(this.scene.artwork), values);
+      const source = { instance, effect: d.id, provider: this.effects.require().id, name: d.name, values };
+      const { group, shots, notes } = motionPartsFromVectorEffect(this.scene.artwork, motion, source, options.box);
+      return { scene: { ...this.scene, artwork: { ...this.scene.artwork, nodes: [...this.scene.artwork.nodes, group] }, shots: [...this.scene.shots, ...shots] }, label: `Add ${d.name}`, instance, notes };
+    });
+  }
+  /**
+   * Makes an applied effect again with new `values` (merged over its own; `null` resets a
+   * control), in the same place. One undo step.
+   */
+  updateMotionEffect(instance, values, options = {}) {
+    return this.effectEdit(async () => {
+      const was = motionSceneEffects(this.scene).find((e) => e.instance === instance);
+      if (!was) throw new Error(`There is no applied effect "${instance}"; list_applied_effects lists them.`);
+      const d = await this.describeFor(was.effect, [was.kind]);
+      const base = { ...was.values };
+      const given = {};
+      for (const [k, v] of Object.entries(values)) {
+        if (v !== null) given[k] = v;
+        else if (k in d.controls.properties) base[k] = d.defaults[k];
+        else throw new Error(`"${k}" is not a control of "${d.id}"; its controls are ${Object.keys(d.controls.properties).join(", ")}.`);
+      }
+      const merged = { ...base, ...resolveEffectValues({ ...d, defaults: base }, given) };
+      const { scene: bare, place } = withoutMotionEffect(this.scene, instance);
+      const provider = this.effects.require();
+      const source = { instance, effect: d.id, provider: provider.id, name: d.name, values: merged };
+      if (was.kind === "vector") {
+        const old = this.scene.artwork.nodes.find((n) => n.id === instance);
+        const motion2 = await provider.applyVectorEffect(d.id, motionArtworkSvg(bare.artwork), merged);
+        const { group, shots: shots2, notes: notes2 } = motionPartsFromVectorEffect(bare.artwork, motion2, source);
+        const index = this.scene.artwork.nodes.findIndex((n) => n.id === instance);
+        const nodes = [...bare.artwork.nodes];
+        nodes.splice(Math.max(0, index), 0, old?.transform ? { ...group, transform: old.transform } : group);
+        const at = this.scene.shots.findIndex((s) => was.shots.includes(s.id));
+        const kept = bare.shots;
+        const nextShots = [...kept.slice(0, Math.max(0, at)), ...shots2, ...kept.slice(Math.max(0, at))];
+        return { scene: { ...bare, artwork: { ...bare.artwork, nodes }, shots: nextShots }, label: `Change ${d.name}`, instance, notes: notes2 };
+      }
+      const motion = await provider.applyVectorEffect(d.id, { svg: motionArtworkSvg(bare.artwork), nodeIds: was.targets }, merged);
+      const { commands, notes } = motionCommandsFromEffect(bare.artwork, motion, source);
+      let shots = bare.shots;
+      if (place && shots.some((s) => s.id === place.shot)) shots = shots.map((s) => s.id === place.shot ? { ...s, run: [...s.run.slice(0, place.index), ...commands, ...s.run.slice(place.index)] } : s);
+      else {
+        const at = this.scene.shots.findIndex((s) => s.id === place?.shot);
+        shots = [...shots.slice(0, Math.max(0, at)), { id: instance, label: d.name, run: commands }, ...shots.slice(Math.max(0, at))];
+      }
+      return { scene: { ...bare, shots }, label: `Change ${d.name}`, instance, notes };
+    }, options.merge);
+  }
+  /** Removes an applied effect: its commands, shots it alone filled and a vector effect's group. One undo step. Works without a provider. */
+  removeMotionEffect(instance) {
+    const was = motionSceneEffects(this.scene).find((e) => e.instance === instance);
+    if (!was) return this.refuse(`There is no applied effect "${instance}"; list_applied_effects lists them.`);
+    const r = this.apply({ op: "replace_scene", scene: withoutMotionEffect(this.scene, instance).scene }, `Remove ${was.name ?? was.effect}`);
+    return r.ok ? { ok: true, effect: was, notes: [] } : r;
+  }
   /** 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;
@@ -4970,6 +5223,85 @@ function parseMotionDrivers(text) {
   }
   return { drivers };
 }
+
+// src/animation-editor/effect-tools.ts
+var info = (e) => ({ id: e.instance, effect: e.effect, ...e.name ? { name: e.name } : {}, ...e.provider ? { provider: e.provider } : {}, role: e.kind === "vector" ? "vector picture" : "motion", enabled: true, values: e.values, targets: e.targets, shots: e.shots });
+function createAnimationEffectsToolProvider(controller, options = {}) {
+  const readOnlyReason = () => {
+    const ro = typeof options.readOnly === "function" ? options.readOnly() : options.readOnly;
+    if (ro) return typeof ro === "string" ? ro : "The animation is read-only.";
+    return controller.readOnlyReason();
+  };
+  const done = (r, target) => {
+    if (!r.ok) throw new Error(r.error);
+    return { target, effect: info(r.effect), effects: controller.appliedEffects().filter((e) => e.targets.includes(target)).map(info), ...r.notes.length ? { notes: r.notes } : {} };
+  };
+  return createEffectToolProvider({
+    id: options.id ?? "animation-effects",
+    namespace: options.namespace,
+    target: { noun: "node", id: "A node id of the artwork from get_animation (a group animates as one)." },
+    applyUses: ["motion"],
+    applyDetails: "The provider animates the node and its changes become ordinary commands (enter, fade, move, pulse\u2026), in a new shot after the last one, tagged with the effect so it can be changed or removed as a whole. They preview, play and export to Flair like any command. Vector effects with their own picture go through add_vector_effect. index, enabled and opacity do not apply here.",
+    provider: () => controller.effectsProvider,
+    readOnlyReason,
+    list: (target) => {
+      const all = controller.appliedEffects();
+      if (target) return [{ target, effects: all.filter((e) => e.targets.includes(target)).map(info) }];
+      const byTarget = /* @__PURE__ */ new Map();
+      for (const e of all) {
+        const key = e.targets[0] ?? e.instance;
+        byTarget.set(key, [...byTarget.get(key) ?? [], info(e)]);
+      }
+      return [...byTarget].map(([t, effects]) => ({ target: t, effects }));
+    },
+    apply: async (target, effect, args) => {
+      if (args.index !== void 0 || args.opacity !== void 0 || args.enabled === false) throw new Error("index, opacity and enabled do not apply to motion effects; the effect becomes commands in a new shot.");
+      return done(await controller.applyMotionEffect(effect, [target], { values: args.values }), target);
+    },
+    update: async (target, instance, changes) => {
+      const extra = ["enabled", "opacity", "index"].filter((k) => changes[k] !== void 0);
+      if (extra.length) throw new Error(`A motion effect only takes values; ${extra.join(", ")} do not apply (move or delete its commands with edit_animation).`);
+      return done(await controller.updateMotionEffect(instance, changes.values ?? {}), target);
+    },
+    remove: async (target, instance) => done(controller.removeMotionEffect(instance), target),
+    subscribe: (notify) => controller.subscribe(() => notify()),
+    extraTools: (ctx) => [
+      {
+        name: "add_vector_effect",
+        title: "Add a vector effect",
+        description: "Adds a provider vector effect that brings its own picture (search_effects with kind vector: lower thirds, loaders, stickers): its SVG becomes an artwork group, fitted into box (default the whole artwork), and its motion becomes shots after the last one. Change it with update_effect (target and effect: the returned instance) or remove it with remove_effect. One undo step. Returns the instance, the group id and any notes on what could not be carried over.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            effect: { type: "string", minLength: 1, description: "A vector effect id from search_effects (kind vector)." },
+            values: ctx.valuesSchema("Control values over the effect's defaults"),
+            box: {
+              type: "object",
+              properties: {
+                x: { type: "number", description: "Left edge, artwork units." },
+                y: { type: "number", description: "Top edge, artwork units." },
+                width: { type: "number", exclusiveMinimum: 0, description: "Width, artwork units." },
+                height: { type: "number", exclusiveMinimum: 0, description: "Height, artwork units." }
+              },
+              required: ["x", "y", "width", "height"],
+              additionalProperties: false,
+              description: "Where the picture goes in the artwork, fitted keeping its proportions (default the whole artwork)."
+            }
+          },
+          required: ["effect"],
+          additionalProperties: false
+        },
+        annotations: { title: "Add a vector effect", ...ctx.annotations.write },
+        handler: async (args) => {
+          ctx.requireProvider();
+          const r = await controller.addVectorEffect(args.effect, { values: args.values, box: args.box });
+          if (!r.ok) throw new Error(r.error);
+          return { instance: r.effect.instance, group: r.effect.group, effect: info(r.effect), ...r.notes.length ? { notes: r.notes } : {} };
+        }
+      }
+    ]
+  });
+}
 export {
   ANIMATION_EDITOR_AGENT_INSTRUCTIONS,
   AnimationEditorController,
@@ -5014,6 +5346,7 @@ export {
   commandShapeProblems,
   compileMotionScene,
   createAnimationEditorToolProvider,
+  createAnimationEffectsToolProvider,
   createMotionScene,
   defaultMotionCommand,
   describeMotionElements,
@@ -5039,6 +5372,7 @@ export {
   isMotionShot,
   matchMotionNodes,
   motionAddTrackKey,
+  motionArtworkSvg,
   motionBeatAt,
   motionBeatTime,
   motionBlurTimes,
@@ -5051,6 +5385,7 @@ export {
   motionCommandRows,
   motionCommandSlots,
   motionCommandSummary,
+  motionCommandsFromEffect,
   motionContactSheetSvg,
   motionCueChoices,
   motionCueFromKey,
@@ -5077,6 +5412,7 @@ export {
   motionNodeAtElement,
   motionNodeClips,
   motionNodeOffset,
+  motionPartsFromVectorEffect,
   motionPath,
   motionPathLength,
   motionPathsSvg,
@@ -5085,6 +5421,7 @@ export {
   motionRevealClip,
   motionRevealPadding,
   motionRulerTicks,
+  motionSceneEffects,
   motionSceneShapeProblems,
   motionSceneToJson,
   motionShotAt,
@@ -5095,6 +5432,7 @@ export {
   motionTextUnits,
   motionTrackKey,
   namedWithSuggestion,
+  nextMotionEffectInstance,
   parseMotionDrivers,
   parseMotionFieldInput,
   parseMotionNarration,
@@ -5113,6 +5451,7 @@ export {
   toLottie,
   trackValue,
   withMotionLayers,
-  withViewBox
+  withViewBox,
+  withoutMotionEffect
 };
 //# sourceMappingURL=index.js.map