route-graphics 1.46.1 → 1.48.0

package/dist/cli/routeGraphicsCli.js

@@ -2624,6 +2624,9 @@ var RECT_STYLE_TWEEN_FIELDS = /* @__PURE__ */ new Set([
   "border",
   "cornerRadius"
 ]);
+var NO_TRACKS = Symbol("no animation tracks");
+var EMPTY_MANUAL_TRACKS = { allowEmptyKeyframes: true };
+var MANUAL_TRACK_FIELDS = /* @__PURE__ */ new Set(["initialValue", "keyframes"]);
 var assertPlainObject3 = (value, path5) => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error(`${path5} must be an object.`);
@@ -2762,16 +2765,23 @@ var normalizeAutoTween = (autoConfig, path5) => {
     ...autoConfig.delay > 0 ? { delay: autoConfig.delay } : {}
   };
 };
-var normalizeKeyframes = (propertyConfig, path5, assertValue = assertNumber, normalizeValue = (value) => Array.isArray(value) ? [...value] : value) => {
+var normalizeKeyframes = (propertyConfig, path5, assertValue = assertNumber, normalizeValue = (value) => Array.isArray(value) ? [...value] : value, { allowEmptyKeyframes = false } = {}) => {
   assertPlainObject3(propertyConfig, path5);
   const normalized = {};
   if (propertyConfig.initialValue !== void 0) {
     assertValue(propertyConfig.initialValue, `${path5}.initialValue`);
     normalized.initialValue = normalizeValue(propertyConfig.initialValue);
   }
-  if (!Array.isArray(propertyConfig.keyframes) || propertyConfig.keyframes.length === 0) {
+  if (!Array.isArray(propertyConfig.keyframes)) {
     throw new Error(`${path5}.keyframes must be a non-empty array.`);
   }
+  if (propertyConfig.keyframes.length === 0) {
+    if (!allowEmptyKeyframes) {
+      throw new Error(`${path5}.keyframes must be a non-empty array.`);
+    }
+    assertKnownFields2(propertyConfig, MANUAL_TRACK_FIELDS, path5);
+    return NO_TRACKS;
+  }
   normalized.keyframes = propertyConfig.keyframes.map((keyframe, index) => {
     const keyframePath = `${path5}.keyframes[${index}]`;
     assertPlainObject3(keyframe, keyframePath);
@@ -2811,14 +2821,15 @@ var normalizeKeyframes = (propertyConfig, path5, assertValue = assertNumber, nor
   });
   return normalized;
 };
-var normalizeShaderTweenMap = (tween, path5) => {
+var normalizeShaderTweenMap = (tween, path5, options = {}) => {
   assertPlainObject3(tween, path5);
+  const { allowEmptyMap = false, ...keyframeOptions } = options;
   const entries = Object.entries(tween);
-  if (entries.length === 0) {
+  if (entries.length === 0 && !allowEmptyMap) {
     throw new Error(`${path5} must define at least one parameter.`);
   }
   return Object.fromEntries(
-    entries.map(([parameter, config]) => {
+    entries.flatMap(([parameter, config]) => {
       if (parameter === "uTime" || parameter === "time") {
         throw new Error(
           `${path5}.${parameter} is read-only. Animate a custom parameter instead.`
@@ -2834,18 +2845,18 @@ var normalizeShaderTweenMap = (tween, path5) => {
           `${path5}.${parameter} must be progress or match ${SHADER_PARAMETER_PATTERN.source}.`
         );
       }
-      return [
-        parameter === "progress" ? "uProgress" : parameter,
-        normalizeKeyframes(
-          config,
-          `${path5}.${parameter}`,
-          parameter === "progress" ? assertShaderProgressValue : assertShaderTweenValue
-        )
-      ];
+      const normalized = normalizeKeyframes(
+        config,
+        `${path5}.${parameter}`,
+        parameter === "progress" ? assertShaderProgressValue : assertShaderTweenValue,
+        void 0,
+        keyframeOptions
+      );
+      return normalized === NO_TRACKS ? [] : [[parameter === "progress" ? "uProgress" : parameter, normalized]];
     })
   );
 };
-var normalizeUpdatePropertyConfig = (propertyConfig, path5) => {
+var normalizeUpdatePropertyConfig = (propertyConfig, path5, options = {}) => {
   assertPlainObject3(propertyConfig, path5);
   const hasKeyframes = propertyConfig.keyframes !== void 0;
   const hasAuto = propertyConfig.auto !== void 0;
@@ -2865,7 +2876,13 @@ var normalizeUpdatePropertyConfig = (propertyConfig, path5) => {
       auto: normalizeAutoTween(propertyConfig.auto, `${path5}.auto`)
     };
   }
-  return normalizeKeyframes(propertyConfig, path5);
+  return normalizeKeyframes(
+    propertyConfig,
+    path5,
+    void 0,
+    void 0,
+    options
+  );
 };
 var normalizeColorValue = (value, path5) => {
   if (typeof value !== "string" || value.length === 0) {
@@ -2877,10 +2894,10 @@ var normalizeColorValue = (value, path5) => {
     throw new Error(`${path5} must be a valid color.`);
   }
 };
-var normalizeColorPropertyConfig = (propertyConfig, path5) => {
+var normalizeColorPropertyConfig = (propertyConfig, path5, options = {}) => {
   assertPlainObject3(propertyConfig, path5);
   if (propertyConfig.auto !== void 0) {
-    return normalizeUpdatePropertyConfig(propertyConfig, path5);
+    return normalizeUpdatePropertyConfig(propertyConfig, path5, options);
   }
   for (const [index, keyframe] of (propertyConfig.keyframes ?? []).entries()) {
     if (keyframe?.relative === true) {
@@ -2895,25 +2912,26 @@ var normalizeColorPropertyConfig = (propertyConfig, path5) => {
     (value, valuePath) => {
       normalizeColorValue(value, valuePath);
     },
-    normalizeColorValue
+    normalizeColorValue,
+    options
   );
 };
 var normalizeRectPointTween = (point, path5, prefix) => {
   assertPlainObject3(point, path5);
   assertKnownFields2(point, /* @__PURE__ */ new Set(["x", "y"]), path5);
-  const entries = Object.entries(point);
-  if (entries.length === 0) {
-    throw new Error(`${path5} must define x or y.`);
-  }
   return Object.fromEntries(
-    entries.map(([axis, config]) => [
-      `${prefix}.${axis}`,
-      normalizeUpdatePropertyConfig(config, `${path5}.${axis}`)
-    ])
+    Object.entries(point).flatMap(([axis, config]) => {
+      const normalized = normalizeUpdatePropertyConfig(
+        config,
+        `${path5}.${axis}`,
+        EMPTY_MANUAL_TRACKS
+      );
+      return normalized === NO_TRACKS ? [] : [[`${prefix}.${axis}`, normalized]];
+    })
   );
 };
 var normalizeRectFillStopsTween = (stops, path5) => {
-  if (!Array.isArray(stops) || stops.length === 0) {
+  if (!Array.isArray(stops)) {
     throw new Error(`${path5} must be a non-empty array.`);
   }
   const indices = /* @__PURE__ */ new Set();
@@ -2933,17 +2951,28 @@ var normalizeRectFillStopsTween = (stops, path5) => {
       if (stop.offset === void 0 && stop.color === void 0) {
         throw new Error(`${itemPath} must define offset or color.`);
       }
-      return {
-        ...stop.offset === void 0 ? {} : {
-          [`rect.fill.stops.${stop.index}.offset`]: normalizeUpdatePropertyConfig(
-            stop.offset,
-            `${itemPath}.offset`
-          )
-        },
-        ...stop.color === void 0 ? {} : {
-          [`rect.fill.stops.${stop.index}.color`]: normalizeColorPropertyConfig(stop.color, `${itemPath}.color`)
+      const stopTracks = {};
+      if (stop.offset !== void 0) {
+        const offset = normalizeUpdatePropertyConfig(
+          stop.offset,
+          `${itemPath}.offset`,
+          EMPTY_MANUAL_TRACKS
+        );
+        if (offset !== NO_TRACKS) {
+          stopTracks[`rect.fill.stops.${stop.index}.offset`] = offset;
         }
-      };
+      }
+      if (stop.color !== void 0) {
+        const color = normalizeColorPropertyConfig(
+          stop.color,
+          `${itemPath}.color`,
+          EMPTY_MANUAL_TRACKS
+        );
+        if (color !== NO_TRACKS) {
+          stopTracks[`rect.fill.stops.${stop.index}.color`] = color;
+        }
+      }
+      return stopTracks;
     })
   );
 };
@@ -2965,53 +2994,67 @@ var normalizeRectFillTween = (fill, path5) => {
     ]),
     path5
   );
-  if (Object.keys(fill).length === 0) {
-    throw new Error(`${path5} must define at least one property.`);
+  const normalized = {};
+  if (fill.color !== void 0) {
+    const color = normalizeColorPropertyConfig(
+      fill.color,
+      `${path5}.color`,
+      EMPTY_MANUAL_TRACKS
+    );
+    if (color !== NO_TRACKS) {
+      normalized["rect.fill.color"] = color;
+    }
+  }
+  for (const [point, prefix] of [
+    ["start", "rect.fill.start"],
+    ["end", "rect.fill.end"],
+    ["innerCenter", "rect.fill.innerCenter"],
+    ["outerCenter", "rect.fill.outerCenter"]
+  ]) {
+    if (fill[point] !== void 0) {
+      Object.assign(
+        normalized,
+        normalizeRectPointTween(fill[point], `${path5}.${point}`, prefix)
+      );
+    }
   }
-  return {
-    ...fill.color === void 0 ? {} : {
-      "rect.fill.color": normalizeColorPropertyConfig(
-        fill.color,
-        `${path5}.color`
-      )
-    },
-    ...fill.start === void 0 ? {} : normalizeRectPointTween(
-      fill.start,
-      `${path5}.start`,
-      "rect.fill.start"
-    ),
-    ...fill.end === void 0 ? {} : normalizeRectPointTween(fill.end, `${path5}.end`, "rect.fill.end"),
-    ...fill.innerCenter === void 0 ? {} : normalizeRectPointTween(
-      fill.innerCenter,
-      `${path5}.innerCenter`,
-      "rect.fill.innerCenter"
-    ),
-    ...fill.outerCenter === void 0 ? {} : normalizeRectPointTween(
-      fill.outerCenter,
-      `${path5}.outerCenter`,
-      "rect.fill.outerCenter"
-    ),
-    ...Object.fromEntries(
-      ["innerRadius", "outerRadius", "scale", "rotation"].filter((property) => fill[property] !== void 0).map((property) => [
-        `rect.fill.${property}`,
-        normalizeUpdatePropertyConfig(fill[property], `${path5}.${property}`)
-      ])
-    ),
-    ...fill.stops === void 0 ? {} : normalizeRectFillStopsTween(fill.stops, `${path5}.stops`)
-  };
+  for (const property of ["innerRadius", "outerRadius", "scale", "rotation"]) {
+    if (fill[property] === void 0) {
+      continue;
+    }
+    const tracks = normalizeUpdatePropertyConfig(
+      fill[property],
+      `${path5}.${property}`,
+      EMPTY_MANUAL_TRACKS
+    );
+    if (tracks !== NO_TRACKS) {
+      normalized[`rect.fill.${property}`] = tracks;
+    }
+  }
+  if (fill.stops !== void 0) {
+    Object.assign(
+      normalized,
+      normalizeRectFillStopsTween(fill.stops, `${path5}.stops`)
+    );
+  }
+  return normalized;
 };
 var normalizeRectBorderTween = (border, path5) => {
   assertPlainObject3(border, path5);
   assertKnownFields2(border, /* @__PURE__ */ new Set(["width", "color", "alpha"]), path5);
-  const entries = Object.entries(border);
-  if (entries.length === 0) {
-    throw new Error(`${path5} must define width, color, or alpha.`);
-  }
   return Object.fromEntries(
-    entries.map(([property, config]) => [
-      `rect.border.${property}`,
-      property === "color" ? normalizeColorPropertyConfig(config, `${path5}.${property}`) : normalizeUpdatePropertyConfig(config, `${path5}.${property}`)
-    ])
+    Object.entries(border).flatMap(([property, config]) => {
+      const normalized = property === "color" ? normalizeColorPropertyConfig(
+        config,
+        `${path5}.${property}`,
+        EMPTY_MANUAL_TRACKS
+      ) : normalizeUpdatePropertyConfig(
+        config,
+        `${path5}.${property}`,
+        EMPTY_MANUAL_TRACKS
+      );
+      return normalized === NO_TRACKS ? [] : [[`rect.border.${property}`, normalized]];
+    })
   );
 };
 var normalizeRectCornerRadiusTween = (cornerRadius, path5) => {
@@ -3024,36 +3067,44 @@ var normalizeRectCornerRadiusTween = (cornerRadius, path5) => {
       /* @__PURE__ */ new Set(["initialValue", "keyframes", "auto"]),
       path5
     );
-    const normalized = normalizeUpdatePropertyConfig(cornerRadius, path5);
+    const normalized = normalizeUpdatePropertyConfig(
+      cornerRadius,
+      path5,
+      EMPTY_MANUAL_TRACKS
+    );
+    if (normalized === NO_TRACKS) {
+      return {};
+    }
     return Object.fromEntries(
       cornerNames.map((corner) => [`rect.cornerRadius.${corner}`, normalized])
     );
   }
   assertKnownFields2(cornerRadius, new Set(cornerNames), path5);
-  const entries = Object.entries(cornerRadius);
-  if (entries.length === 0) {
-    throw new Error(`${path5} must define at least one corner.`);
-  }
   return Object.fromEntries(
-    entries.map(([corner, config]) => [
-      `rect.cornerRadius.${corner}`,
-      normalizeUpdatePropertyConfig(config, `${path5}.${corner}`)
-    ])
+    Object.entries(cornerRadius).flatMap(([corner, config]) => {
+      const normalized = normalizeUpdatePropertyConfig(
+        config,
+        `${path5}.${corner}`,
+        EMPTY_MANUAL_TRACKS
+      );
+      return normalized === NO_TRACKS ? [] : [[`rect.cornerRadius.${corner}`, normalized]];
+    })
   );
 };
 var normalizeRectStyleTween = (rectTween, path5) => {
   const normalized = {};
-  if (rectTween.width !== void 0) {
-    normalized["rect.width"] = normalizeUpdatePropertyConfig(
-      rectTween.width,
-      `${path5}.width`
-    );
-  }
-  if (rectTween.height !== void 0) {
-    normalized["rect.height"] = normalizeUpdatePropertyConfig(
-      rectTween.height,
-      `${path5}.height`
+  for (const property of ["width", "height"]) {
+    if (rectTween[property] === void 0) {
+      continue;
+    }
+    const tracks = normalizeUpdatePropertyConfig(
+      rectTween[property],
+      `${path5}.${property}`,
+      EMPTY_MANUAL_TRACKS
     );
+    if (tracks !== NO_TRACKS) {
+      normalized[`rect.${property}`] = tracks;
+    }
   }
   if (rectTween.fill !== void 0) {
     Object.assign(
@@ -3078,7 +3129,8 @@ var normalizeRectStyleTween = (rectTween, path5) => {
   }
   return normalized;
 };
-var normalizeTweenMap = (tween, path5, allowedProperties, propertyNormalizer = normalizeKeyframes) => {
+var normalizeSurfacePropertyConfig = (propertyConfig, path5, options) => normalizeKeyframes(propertyConfig, path5, void 0, void 0, options);
+var normalizeTweenMap = (tween, path5, allowedProperties, propertyNormalizer = normalizeSurfacePropertyConfig, options = EMPTY_MANUAL_TRACKS) => {
   assertPlainObject3(tween, path5);
   if (tween.x !== void 0 && tween.translateX !== void 0) {
     throw new Error(`${path5} cannot define both x and translateX.`);
@@ -3086,29 +3138,33 @@ var normalizeTweenMap = (tween, path5, allowedProperties, propertyNormalizer = n
   if (tween.y !== void 0 && tween.translateY !== void 0) {
     throw new Error(`${path5} cannot define both y and translateY.`);
   }
-  const normalizedEntries = Object.entries(tween).map(([property, config]) => {
-    if (!allowedProperties.has(property)) {
-      throw new Error(
-        `${path5}.${property} is not a supported animation property.`
+  return Object.fromEntries(
+    Object.entries(tween).flatMap(([property, config]) => {
+      if (!allowedProperties.has(property)) {
+        throw new Error(
+          `${path5}.${property} is not a supported animation property.`
+        );
+      }
+      const normalizedProperty = propertyNormalizer(
+        config,
+        `${path5}.${property}`,
+        options
       );
-    }
-    return [property, propertyNormalizer(config, `${path5}.${property}`)];
-  });
-  if (normalizedEntries.length === 0) {
-    throw new Error(`${path5} must define at least one property.`);
-  }
-  return Object.fromEntries(normalizedEntries);
+      return normalizedProperty === NO_TRACKS ? [] : [[property, normalizedProperty]];
+    })
+  );
 };
 var normalizeFilterTweens = (filters, path5) => {
   assertPlainObject3(filters, path5);
-  const entries = Object.entries(filters);
-  if (entries.length === 0) {
-    throw new Error(`${path5} must target at least one filter.`);
-  }
   return Object.fromEntries(
-    entries.map(([filterId, tween]) => {
+    Object.entries(filters).flatMap(([filterId, tween]) => {
       assertString(filterId, `${path5} filter id`);
-      return [filterId, normalizeShaderTweenMap(tween, `${path5}.${filterId}`)];
+      const tweenTracks = normalizeShaderTweenMap(
+        tween,
+        `${path5}.${filterId}`,
+        { allowEmptyMap: true, allowEmptyKeyframes: true }
+      );
+      return Object.keys(tweenTracks).length === 0 ? [] : [[filterId, tweenTracks]];
     })
   );
 };
@@ -3125,26 +3181,31 @@ var normalizeUpdateTween = (tween, path5) => {
       ([property]) => !RECT_STYLE_TWEEN_FIELDS.has(property)
     )
   );
-  const normalized = {};
+  const tracks = {};
   if (Object.keys(elementTween).length > 0) {
-    normalized.tween = normalizeTweenMap(
-      elementTween,
-      path5,
-      UPDATE_TWEEN_PROPERTIES,
-      normalizeUpdatePropertyConfig
+    Object.assign(
+      tracks,
+      normalizeTweenMap(
+        elementTween,
+        path5,
+        UPDATE_TWEEN_PROPERTIES,
+        normalizeUpdatePropertyConfig,
+        EMPTY_MANUAL_TRACKS
+      )
     );
   }
   if (Object.keys(rectTween).length > 0) {
-    normalized.tween = {
-      ...normalized.tween,
-      ...normalizeRectStyleTween(rectTween, path5)
-    };
+    Object.assign(tracks, normalizeRectStyleTween(rectTween, path5));
   }
-  if (filters !== void 0) {
-    normalized.filterTweens = normalizeFilterTweens(filters, `${path5}.filters`);
+  const normalized = {};
+  if (Object.keys(tracks).length > 0) {
+    normalized.tween = tracks;
   }
-  if (normalized.tween === void 0 && normalized.filterTweens === void 0) {
-    throw new Error(`${path5} must define an element property or filters.`);
+  if (filters !== void 0) {
+    const filterTweens = normalizeFilterTweens(filters, `${path5}.filters`);
+    if (Object.keys(filterTweens).length > 0) {
+      normalized.filterTweens = filterTweens;
+    }
   }
   return normalized;
 };
@@ -3290,6 +3351,9 @@ var normalizeReplaceSide = (side, path5) => {
   if (side.mask !== void 0) {
     throw new Error(`${path5}.mask is not valid. Define mask on ${path5}.`);
   }
+  if (side.tween === void 0 && Object.keys(side).length > 0) {
+    throw new Error(`${path5} must define tween.`);
+  }
   const normalized = {};
   if (side.tween !== void 0) {
     normalized.tween = normalizeTweenMap(
@@ -3298,18 +3362,27 @@ var normalizeReplaceSide = (side, path5) => {
       TRANSITION_TWEEN_PROPERTIES
     );
   }
-  if (Object.keys(normalized).length === 0) {
-    throw new Error(`${path5} must define tween.`);
+  if (!normalized.tween || Object.keys(normalized.tween).length === 0) {
+    assertKnownFields2(side, /* @__PURE__ */ new Set(["tween"]), path5);
   }
   return normalized;
 };
 var normalizeReplacePayload = (animation, path5) => {
+  if (animation.prev === void 0 && animation.next === void 0 && animation.mask === void 0 && animation.compositor === void 0) {
+    throw new Error(`${path5} must define prev, next, mask, or compositor.`);
+  }
   const normalized = {};
   if (animation.prev !== void 0) {
-    normalized.prev = normalizeReplaceSide(animation.prev, `${path5}.prev`);
+    const prev = normalizeReplaceSide(animation.prev, `${path5}.prev`);
+    if (prev.tween && Object.keys(prev.tween).length > 0) {
+      normalized.prev = prev;
+    }
   }
   if (animation.next !== void 0) {
-    normalized.next = normalizeReplaceSide(animation.next, `${path5}.next`);
+    const next = normalizeReplaceSide(animation.next, `${path5}.next`);
+    if (next.tween && Object.keys(next.tween).length > 0) {
+      normalized.next = next;
+    }
   }
   if (animation.mask !== void 0) {
     normalized.mask = normalizeMasks(animation.mask, `${path5}.mask`);
@@ -3334,9 +3407,6 @@ var normalizeReplacePayload = (animation, path5) => {
       );
     }
   }
-  if (normalized.prev === void 0 && normalized.next === void 0 && normalized.mask === void 0 && normalized.compositor === void 0) {
-    throw new Error(`${path5} must define prev, next, mask, or compositor.`);
-  }
   return normalized;
 };
 var assertLegacyFieldAbsent = (value, path5, message) => {
@@ -3348,7 +3418,7 @@ var normalizeAnimations = (animations = []) => {
   if (!Array.isArray(animations)) {
     throw new Error("Input error: `animations` must be an array.");
   }
-  const normalized = animations.map((animation, index) => {
+  const normalizedEntries = animations.map((animation, index) => {
     const path5 = `animations[${index}]`;
     assertPlainObject3(animation, path5);
     assertString(animation.id, `${path5}.id`);
@@ -3422,6 +3492,11 @@ var normalizeAnimations = (animations = []) => {
       if (animation.tween !== void 0 && animation.gsap !== void 0) {
         throw new Error(`${path5} cannot define both tween and gsap.`);
       }
+      if (animation.tween === void 0 && animation.gsap === void 0) {
+        throw new Error(
+          `${path5} must define exactly one of tween or gsap for an update animation.`
+        );
+      }
       if (animation.tween !== void 0) {
         Object.assign(
           normalizedAnimation,
@@ -3435,11 +3510,6 @@ var normalizeAnimations = (animations = []) => {
           "update"
         );
       }
-      if (normalizedAnimation.tween === void 0 && normalizedAnimation.filterTweens === void 0 && normalizedAnimation.gsap === void 0) {
-        throw new Error(
-          `${path5} must define exactly one of tween or gsap for an update animation.`
-        );
-      }
       if (animation.replace !== void 0) {
         throw new Error(
           `${path5}.replace is no longer supported. Define \`prev\`, \`next\`, or \`mask\` directly on the animation.`
@@ -3465,7 +3535,7 @@ var normalizeAnimations = (animations = []) => {
           `${path5}.compositor is only valid for transition animations.`
         );
       }
-      return normalizedAnimation;
+      return normalizedAnimation.tween === void 0 && normalizedAnimation.filterTweens === void 0 && normalizedAnimation.gsap === void 0 ? null : normalizedAnimation;
     }
     if (animation.tween !== void 0) {
       throw new Error(`${path5}.tween is not valid for transition animations.`);
@@ -3535,11 +3605,15 @@ var normalizeAnimations = (animations = []) => {
     if (normalizedReplace.compositor !== void 0) {
       normalizedAnimation.compositor = normalizedReplace.compositor;
     }
-    return normalizedAnimation;
+    return Object.keys(normalizedReplace).length === 0 ? null : normalizedAnimation;
   });
+  const normalized = normalizedEntries.filter(
+    (animation) => animation !== null
+  );
   const animationIds = /* @__PURE__ */ new Map();
   const transitionTargets = /* @__PURE__ */ new Map();
-  for (const [index, animation] of normalized.entries()) {
+  for (const [index, animation] of normalizedEntries.entries()) {
+    if (animation === null) continue;
     const priorIdIndex = animationIds.get(animation.id);
     if (priorIdIndex !== void 0) {
       throw new Error(
@@ -6589,10 +6663,12 @@ var inspectTimelineDefinition = ({
     );
   }
   const state = normalizeRenderState(rawState);
-  const indexedAnimations = state.animations.map((animation, index) => ({
-    animation,
-    index
-  }));
+  const indexedAnimations = (rawState.animations ?? []).flatMap(
+    (raw, index) => {
+      const [animation] = normalizeAnimations([raw]);
+      return animation ? [{ animation, index }] : [];
+    }
+  );
   const selected = animationId ? indexedAnimations.filter(({ animation }) => animation.id === animationId) : indexedAnimations;
   if (animationId && selected.length === 0) {
     throw new Error(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "route-graphics",
-  "version": "1.46.1",
+  "version": "1.48.0",
   "description": "A 2D graphics rendering interface that takes JSON input and renders pixels using PixiJS",
   "main": "dist/RouteGraphics.js",
   "type": "module",
@@ -71,6 +71,7 @@
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.8",
+    "ajv": "8.17.1",
     "canvas": "3.2.0",
     "esbuild": "^0.25.6",
     "husky": "^9.1.7",