@routevn/creator-model 1.8.0 → 1.8.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@routevn/creator-model",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "private": false,
   "type": "module",
   "license": "MIT",

package/src/model.js

@@ -23,6 +23,7 @@ const COLLECTION_KEYS = [
   "images",
   "spritesheets",
   "sounds",
+  "voices",
   "videos",
   "animations",
   "particles",
@@ -245,6 +246,7 @@ const normalizeStateCollections = (state) => {
     "spritesheets",
     "particles",
     "controls",
+    "voices",
   ].filter((key) => state[key] === undefined);
   const normalizedTags = normalizeTagsState(state.tags);
   const hasNormalizedTags = normalizedTags !== state.tags;
@@ -1443,6 +1445,105 @@ const validateSoundItems = ({ items, path, errorFactory }) => {
   }
 };
 
+const validateVoiceItems = ({ items, path, errorFactory }) => {
+  for (const [itemId, item] of Object.entries(items)) {
+    const itemPath = `${path}.${itemId}`;
+
+    if (item?.type !== "folder" && item?.type !== "voice") {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.type must be 'folder' or 'voice'`,
+      );
+    }
+
+    {
+      const result = validateAllowedKeys({
+        value: item,
+        allowedKeys:
+          item.type === "folder"
+            ? ["id", "type", "name", "description"]
+            : [
+                "id",
+                "type",
+                "name",
+                "description",
+                "sceneId",
+                "fileId",
+                "waveformDataFileId",
+                "duration",
+              ],
+        path: itemPath,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (!isNonEmptyString(item.id)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.id must be a non-empty string`,
+      );
+    }
+
+    if (item.id !== itemId) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.id must match item key '${itemId}'`,
+      );
+    }
+
+    if (!isNonEmptyString(item.name)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.name must be a non-empty string`,
+      );
+    }
+
+    if (item.description !== undefined && !isString(item.description)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.description must be a string when provided`,
+      );
+    }
+
+    if (item.type === "voice") {
+      if (!isNonEmptyString(item.sceneId)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.sceneId must be a non-empty string`,
+        );
+      }
+
+      if (!isNonEmptyString(item.fileId)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.fileId must be a non-empty string`,
+        );
+      }
+
+      if (
+        item.waveformDataFileId !== undefined &&
+        item.waveformDataFileId !== null &&
+        !isNonEmptyString(item.waveformDataFileId)
+      ) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.waveformDataFileId must be a non-empty string or null when provided`,
+        );
+      }
+
+      if (item.duration !== undefined && !isFiniteNumber(item.duration)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.duration must be a finite number`,
+        );
+      }
+    }
+  }
+};
+
 const validateVideoItems = ({ items, path, errorFactory }) => {
   for (const [itemId, item] of Object.entries(items)) {
     const itemPath = `${path}.${itemId}`;
@@ -6411,6 +6512,17 @@ const validateCollection = ({ collection, path }) => {
         return result;
       }
     }
+  } else if (path === "state.voices") {
+    {
+      const result = validateVoiceItems({
+        items: collection.items,
+        path: `${path}.items`,
+        errorFactory: createStateValidationError,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   } else if (path === "state.videos") {
     {
       const result = validateVideoItems({
@@ -6596,6 +6708,18 @@ const validateCollection = ({ collection, path }) => {
         return result;
       }
     }
+  } else if (path === "state.voices") {
+    {
+      const result = validateGenericFolderOwnership({
+        nodes: collection.tree,
+        items: collection.items,
+        path: `${path}.tree`,
+        folderLabel: "folder voice item",
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   } else if (path === "state.videos") {
     {
       const result = validateVideoTreeFolderOwnership({
@@ -7116,6 +7240,55 @@ export const assertInvariants = ({ state }) => {
     }
   }
 
+  for (const [voiceId, voice] of Object.entries(state.voices.items)) {
+    if (voice.type !== "voice") {
+      continue;
+    }
+
+    if (!isPlainObject(sceneItems[voice.sceneId])) {
+      return invalidInvariant(
+        "voice.sceneId must reference an existing scene",
+        { voiceId, sceneId: voice.sceneId },
+      );
+    }
+
+    if (sceneItems[voice.sceneId].type === "folder") {
+      return invalidInvariant(
+        "voice.sceneId must reference a non-folder scene",
+        { voiceId, sceneId: voice.sceneId },
+      );
+    }
+
+    {
+      const result = validateFileReference({
+        state,
+        fileId: voice.fileId,
+        path: "voice.fileId",
+        details: { voiceId, fileId: voice.fileId },
+        errorFactory: createInvariantValidationError,
+      });
+      if (!result.valid) {
+        return result;
+      }
+    }
+
+    if (
+      voice.waveformDataFileId !== undefined &&
+      voice.waveformDataFileId !== null
+    ) {
+      const result = validateFileReference({
+        state,
+        fileId: voice.waveformDataFileId,
+        path: "voice.waveformDataFileId",
+        details: { voiceId, waveformDataFileId: voice.waveformDataFileId },
+        errorFactory: createInvariantValidationError,
+      });
+      if (!result.valid) {
+        return result;
+      }
+    }
+  }
+
   for (const [videoId, video] of Object.entries(state.videos.items)) {
     if (video.type !== "video") {
       continue;
@@ -9274,7 +9447,7 @@ const validateSoundUpdateData = ({ data, errorFactory }) => {
   }
 };
 
-const validateVideoCreateData = ({ data, errorFactory }) => {
+const validateVoiceCreateData = ({ data, errorFactory }) => {
   if (!isPlainObject(data)) {
     return invalidFromErrorFactory(
       errorFactory,
@@ -9282,10 +9455,10 @@ const validateVideoCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type !== "folder" && data.type !== "video") {
+  if (data.type !== "folder" && data.type !== "voice") {
     return invalidFromErrorFactory(
       errorFactory,
-      "payload.data.type must be 'folder' or 'video'",
+      "payload.data.type must be 'folder' or 'voice'",
     );
   }
 
@@ -9299,12 +9472,10 @@ const validateVideoCreateData = ({ data, errorFactory }) => {
               "type",
               "name",
               "description",
-              "tagIds",
+              "sceneId",
               "fileId",
-              "thumbnailFileId",
+              "waveformDataFileId",
               "duration",
-              "width",
-              "height",
             ],
       path: "payload.data",
       errorFactory,
@@ -9328,16 +9499,12 @@ const validateVideoCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type === "video") {
-    {
-      const result = validateOptionalUniqueIdArray({
-        value: data.tagIds,
-        path: "payload.data.tagIds",
+  if (data.type === "voice") {
+    if (!isNonEmptyString(data.sceneId)) {
+      return invalidFromErrorFactory(
         errorFactory,
-      });
-      if (result?.valid === false) {
-        return result;
-      }
+        "payload.data.sceneId must be a non-empty string",
+      );
     }
 
     if (!isNonEmptyString(data.fileId)) {
@@ -9347,10 +9514,14 @@ const validateVideoCreateData = ({ data, errorFactory }) => {
       );
     }
 
-    if (!isNonEmptyString(data.thumbnailFileId)) {
+    if (
+      data.waveformDataFileId !== undefined &&
+      data.waveformDataFileId !== null &&
+      !isNonEmptyString(data.waveformDataFileId)
+    ) {
       return invalidFromErrorFactory(
         errorFactory,
-        "payload.data.thumbnailFileId must be a non-empty string",
+        "payload.data.waveformDataFileId must be a non-empty string or null when provided",
       );
     }
 
@@ -9360,36 +9531,20 @@ const validateVideoCreateData = ({ data, errorFactory }) => {
         "payload.data.duration must be a finite number",
       );
     }
-
-    if (data.width !== undefined && !isFiniteNumber(data.width)) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        "payload.data.width must be a finite number",
-      );
-    }
-
-    if (data.height !== undefined && !isFiniteNumber(data.height)) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        "payload.data.height must be a finite number",
-      );
-    }
   }
 };
 
-const validateVideoUpdateData = ({ data, errorFactory }) => {
+const validateVoiceUpdateData = ({ data, errorFactory }) => {
   {
     const result = validateAllowedKeys({
       value: data,
       allowedKeys: [
         "name",
         "description",
-        "tagIds",
+        "sceneId",
         "fileId",
-        "thumbnailFileId",
+        "waveformDataFileId",
         "duration",
-        "width",
-        "height",
       ],
       path: "payload.data",
       errorFactory,
@@ -9420,15 +9575,11 @@ const validateVideoUpdateData = ({ data, errorFactory }) => {
     );
   }
 
-  {
-    const result = validateOptionalUniqueIdArray({
-      value: data.tagIds,
-      path: "payload.data.tagIds",
+  if (data.sceneId !== undefined && !isNonEmptyString(data.sceneId)) {
+    return invalidFromErrorFactory(
       errorFactory,
-    });
-    if (result?.valid === false) {
-      return result;
-    }
+      "payload.data.sceneId must be a non-empty string when provided",
+    );
   }
 
   if (data.fileId !== undefined && !isNonEmptyString(data.fileId)) {
@@ -9439,12 +9590,13 @@ const validateVideoUpdateData = ({ data, errorFactory }) => {
   }
 
   if (
-    data.thumbnailFileId !== undefined &&
-    !isNonEmptyString(data.thumbnailFileId)
+    data.waveformDataFileId !== undefined &&
+    data.waveformDataFileId !== null &&
+    !isNonEmptyString(data.waveformDataFileId)
   ) {
     return invalidFromErrorFactory(
       errorFactory,
-      "payload.data.thumbnailFileId must be a non-empty string when provided",
+      "payload.data.waveformDataFileId must be a non-empty string or null when provided",
     );
   }
 
@@ -9454,23 +9606,9 @@ const validateVideoUpdateData = ({ data, errorFactory }) => {
       "payload.data.duration must be a finite number",
     );
   }
-
-  if (data.width !== undefined && !isFiniteNumber(data.width)) {
-    return invalidFromErrorFactory(
-      errorFactory,
-      "payload.data.width must be a finite number",
-    );
-  }
-
-  if (data.height !== undefined && !isFiniteNumber(data.height)) {
-    return invalidFromErrorFactory(
-      errorFactory,
-      "payload.data.height must be a finite number",
-    );
-  }
 };
 
-const validateFontCreateData = ({ data, errorFactory }) => {
+const validateVideoCreateData = ({ data, errorFactory }) => {
   if (!isPlainObject(data)) {
     return invalidFromErrorFactory(
       errorFactory,
@@ -9478,10 +9616,10 @@ const validateFontCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type !== "folder" && data.type !== "font") {
+  if (data.type !== "folder" && data.type !== "video") {
     return invalidFromErrorFactory(
       errorFactory,
-      "payload.data.type must be 'folder' or 'font'",
+      "payload.data.type must be 'folder' or 'video'",
     );
   }
 
@@ -9491,7 +9629,17 @@ const validateFontCreateData = ({ data, errorFactory }) => {
       allowedKeys:
         data.type === "folder"
           ? ["type", "name", "description"]
-          : ["type", "name", "description", "tagIds", "fileId", "fontFamily"],
+          : [
+              "type",
+              "name",
+              "description",
+              "tagIds",
+              "fileId",
+              "thumbnailFileId",
+              "duration",
+              "width",
+              "height",
+            ],
       path: "payload.data",
       errorFactory,
     });
@@ -9514,7 +9662,7 @@ const validateFontCreateData = ({ data, errorFactory }) => {
     );
   }
 
-  if (data.type === "font") {
+  if (data.type === "video") {
     {
       const result = validateOptionalUniqueIdArray({
         value: data.tagIds,
@@ -9533,23 +9681,209 @@ const validateFontCreateData = ({ data, errorFactory }) => {
       );
     }
 
-    if (!isNonEmptyString(data.fontFamily)) {
+    if (!isNonEmptyString(data.thumbnailFileId)) {
       return invalidFromErrorFactory(
         errorFactory,
-        "payload.data.fontFamily must be a non-empty string",
+        "payload.data.thumbnailFileId must be a non-empty string",
       );
     }
-  }
-};
 
-const validateFontUpdateData = ({ data, errorFactory }) => {
-  {
-    const result = validateAllowedKeys({
-      value: data,
-      allowedKeys: ["name", "description", "tagIds", "fileId", "fontFamily"],
-      path: "payload.data",
-      errorFactory,
-    });
+    if (data.duration !== undefined && !isFiniteNumber(data.duration)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.duration must be a finite number",
+      );
+    }
+
+    if (data.width !== undefined && !isFiniteNumber(data.width)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.width must be a finite number",
+      );
+    }
+
+    if (data.height !== undefined && !isFiniteNumber(data.height)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.height must be a finite number",
+      );
+    }
+  }
+};
+
+const validateVideoUpdateData = ({ data, errorFactory }) => {
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys: [
+        "name",
+        "description",
+        "tagIds",
+        "fileId",
+        "thumbnailFileId",
+        "duration",
+        "width",
+        "height",
+      ],
+      path: "payload.data",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  if (Object.keys(data).length === 0) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data must include at least one updatable field",
+    );
+  }
+
+  if (data.name !== undefined && !isNonEmptyString(data.name)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.name must be a non-empty string when provided",
+    );
+  }
+
+  if (data.description !== undefined && !isString(data.description)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.description must be a string when provided",
+    );
+  }
+
+  {
+    const result = validateOptionalUniqueIdArray({
+      value: data.tagIds,
+      path: "payload.data.tagIds",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  if (data.fileId !== undefined && !isNonEmptyString(data.fileId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.fileId must be a non-empty string when provided",
+    );
+  }
+
+  if (
+    data.thumbnailFileId !== undefined &&
+    !isNonEmptyString(data.thumbnailFileId)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.thumbnailFileId must be a non-empty string when provided",
+    );
+  }
+
+  if (data.duration !== undefined && !isFiniteNumber(data.duration)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.duration must be a finite number",
+    );
+  }
+
+  if (data.width !== undefined && !isFiniteNumber(data.width)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.width must be a finite number",
+    );
+  }
+
+  if (data.height !== undefined && !isFiniteNumber(data.height)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.height must be a finite number",
+    );
+  }
+};
+
+const validateFontCreateData = ({ data, errorFactory }) => {
+  if (!isPlainObject(data)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data must be an object",
+    );
+  }
+
+  if (data.type !== "folder" && data.type !== "font") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.type must be 'folder' or 'font'",
+    );
+  }
+
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys:
+        data.type === "folder"
+          ? ["type", "name", "description"]
+          : ["type", "name", "description", "tagIds", "fileId", "fontFamily"],
+      path: "payload.data",
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
+    }
+  }
+
+  if (!isNonEmptyString(data.name)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.name must be a non-empty string",
+    );
+  }
+
+  if (data.description !== undefined && !isString(data.description)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.description must be a string when provided",
+    );
+  }
+
+  if (data.type === "font") {
+    {
+      const result = validateOptionalUniqueIdArray({
+        value: data.tagIds,
+        path: "payload.data.tagIds",
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (!isNonEmptyString(data.fileId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.fileId must be a non-empty string",
+      );
+    }
+
+    if (!isNonEmptyString(data.fontFamily)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.fontFamily must be a non-empty string",
+      );
+    }
+  }
+};
+
+const validateFontUpdateData = ({ data, errorFactory }) => {
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys: ["name", "description", "tagIds", "fileId", "fontFamily"],
+      path: "payload.data",
+      errorFactory,
+    });
     if (result?.valid === false) {
       return result;
     }
@@ -12854,6 +13188,28 @@ const findReferencedFileUsage = ({ state, fileId }) => {
     }
   }
 
+  for (const [voiceId, voice] of Object.entries(state.voices.items)) {
+    if (voice.type !== "voice") {
+      continue;
+    }
+
+    if (voice.fileId === fileId) {
+      return {
+        kind: "voice",
+        field: "fileId",
+        ownerId: voiceId,
+      };
+    }
+
+    if (voice.waveformDataFileId === fileId) {
+      return {
+        kind: "voice",
+        field: "waveformDataFileId",
+        ownerId: voiceId,
+      };
+    }
+  }
+
   for (const [videoId, video] of Object.entries(state.videos.items)) {
     if (video.type !== "video") {
       continue;
@@ -15384,6 +15740,431 @@ const COMMAND_DEFINITIONS = [
       return state;
     },
   },
+  {
+    type: "voice.create",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateAllowedKeys({
+          value: payload,
+          allowedKeys: [
+            "voiceId",
+            "parentId",
+            "data",
+            "index",
+            "position",
+            "positionTargetId",
+          ],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
+      }
+
+      if (
+        payload.parentId !== undefined &&
+        payload.parentId !== null &&
+        !isNonEmptyString(payload.parentId)
+      ) {
+        return invalidPayload(
+          "payload.parentId must be a non-empty string when provided",
+        );
+      }
+
+      {
+        const result = validateVoiceCreateData({
+          data: payload.data,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      {
+        const result = validatePlacementFields({
+          payload,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      if (isPlainObject(state.voices.items[payload.voiceId])) {
+        return invalidPrecondition("payload.voiceId must not already exist");
+      }
+
+      const parentId = payload.parentId ?? null;
+      if (parentId !== null) {
+        const parentVoice = state.voices.items[parentId];
+        if (!isPlainObject(parentVoice)) {
+          return invalidPrecondition(
+            "payload.parentId must reference an existing voice item",
+          );
+        }
+
+        if (parentVoice.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder voice item",
+          );
+        }
+      }
+
+      if (payload.positionTargetId !== undefined) {
+        if (!isPlainObject(state.voices.items[payload.positionTargetId])) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing voice item",
+          );
+        }
+
+        const targetParentId = getNodeParentId({
+          tree: state.voices.tree,
+          nodeId: payload.positionTargetId,
+        });
+
+        if (targetParentId !== parentId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a sibling under payload.parentId",
+          );
+        }
+      }
+
+      if (payload.data.type === "voice") {
+        const scene = state.scenes.items[payload.data.sceneId];
+        if (!isPlainObject(scene) || scene.type === "folder") {
+          return invalidPrecondition(
+            "payload.data.sceneId must reference an existing non-folder scene",
+          );
+        }
+
+        return validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["fileId", "waveformDataFileId"],
+          nullableFields: ["waveformDataFileId"],
+          details: {
+            voiceId: payload.voiceId,
+          },
+        });
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const nextVoice = {
+        id: payload.voiceId,
+        type: payload.data.type,
+        name: payload.data.name,
+      };
+
+      if (payload.data.description !== undefined) {
+        nextVoice.description = payload.data.description;
+      }
+
+      if (payload.data.type === "voice") {
+        nextVoice.sceneId = payload.data.sceneId;
+        nextVoice.fileId = payload.data.fileId;
+        if (payload.data.waveformDataFileId !== undefined) {
+          nextVoice.waveformDataFileId = payload.data.waveformDataFileId;
+        }
+        if (payload.data.duration !== undefined) {
+          nextVoice.duration = payload.data.duration;
+        }
+      }
+
+      state.voices.items[payload.voiceId] = nextVoice;
+
+      insertTreeNode({
+        tree: state.voices.tree,
+        node: {
+          id: payload.voiceId,
+          children: [],
+        },
+        parentId: payload.parentId ?? null,
+        index: payload.index,
+        position: payload.position,
+        positionTargetId: payload.positionTargetId,
+      });
+
+      return state;
+    },
+  },
+  {
+    type: "voice.update",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateExactKeys({
+          value: payload,
+          expectedKeys: ["voiceId", "data"],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
+      }
+
+      {
+        const result = validateVoiceUpdateData({
+          data: payload.data,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      const currentVoice = state.voices.items[payload.voiceId];
+      if (!isPlainObject(currentVoice)) {
+        return invalidPrecondition(
+          "payload.voiceId must reference an existing voice item",
+        );
+      }
+
+      if (
+        currentVoice.type === "folder" &&
+        (payload.data.sceneId !== undefined ||
+          payload.data.fileId !== undefined ||
+          payload.data.waveformDataFileId !== undefined ||
+          payload.data.duration !== undefined)
+      ) {
+        return invalidPrecondition(
+          "folder voice items cannot update file fields",
+        );
+      }
+
+      if (currentVoice.type === "voice") {
+        if (payload.data.sceneId !== undefined) {
+          const scene = state.scenes.items[payload.data.sceneId];
+          if (!isPlainObject(scene) || scene.type === "folder") {
+            return invalidPrecondition(
+              "payload.data.sceneId must reference an existing non-folder scene",
+            );
+          }
+        }
+
+        return validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["fileId", "waveformDataFileId"],
+          nullableFields: ["waveformDataFileId"],
+          details: {
+            voiceId: payload.voiceId,
+          },
+        });
+      }
+    },
+    reduce: ({ state, payload }) => {
+      state.voices.items[payload.voiceId] = {
+        ...structuredClone(state.voices.items[payload.voiceId]),
+        ...structuredClone(payload.data),
+      };
+      return state;
+    },
+  },
+  {
+    type: "voice.delete",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateExactKeys({
+          value: payload,
+          expectedKeys: ["voiceIds"],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      {
+        const result = validateRequiredUniqueIdArray({
+          value: payload.voiceIds,
+          path: "payload.voiceIds",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      for (const voiceId of payload.voiceIds) {
+        if (!isPlainObject(state.voices.items[voiceId])) {
+          return invalidPrecondition(
+            "payload.voiceIds must reference existing voice items",
+            { voiceId },
+          );
+        }
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const deletedVoiceIds = new Set();
+
+      for (const voiceId of payload.voiceIds) {
+        const removedNode = removeTreeNode({
+          nodes: state.voices.tree,
+          nodeId: voiceId,
+        });
+
+        if (!removedNode) {
+          continue;
+        }
+
+        for (const id of collectTreeDescendantIds({ node: removedNode })) {
+          deletedVoiceIds.add(id);
+        }
+      }
+
+      for (const voiceId of deletedVoiceIds) {
+        delete state.voices.items[voiceId];
+      }
+
+      return state;
+    },
+  },
+  {
+    type: "voice.move",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateAllowedKeys({
+          value: payload,
+          allowedKeys: [
+            "voiceId",
+            "parentId",
+            "index",
+            "position",
+            "positionTargetId",
+          ],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
+      }
+
+      if (
+        payload.parentId !== undefined &&
+        payload.parentId !== null &&
+        !isNonEmptyString(payload.parentId)
+      ) {
+        return invalidPayload(
+          "payload.parentId must be a non-empty string when provided",
+        );
+      }
+
+      {
+        const result = validatePlacementFields({
+          payload,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      const voice = state.voices.items[payload.voiceId];
+      if (!isPlainObject(voice)) {
+        return invalidPrecondition(
+          "payload.voiceId must reference an existing voice item",
+        );
+      }
+
+      const voiceNode = findTreeNode({
+        nodes: state.voices.tree,
+        nodeId: payload.voiceId,
+      });
+
+      if (payload.parentId !== undefined && payload.parentId !== null) {
+        const parentVoice = state.voices.items[payload.parentId];
+        if (!isPlainObject(parentVoice)) {
+          return invalidPrecondition(
+            "payload.parentId must reference an existing voice item",
+          );
+        }
+
+        if (parentVoice.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder voice item",
+          );
+        }
+
+        const descendantIds = new Set(
+          collectTreeDescendantIds({
+            node: voiceNode,
+          }),
+        );
+
+        if (descendantIds.has(payload.parentId)) {
+          return invalidPrecondition(
+            "payload.parentId must not target the moved voice item or its descendants",
+          );
+        }
+      }
+
+      if (payload.positionTargetId !== undefined) {
+        if (payload.positionTargetId === payload.voiceId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must not reference the moved voice item",
+          );
+        }
+
+        if (!isPlainObject(state.voices.items[payload.positionTargetId])) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing voice item",
+          );
+        }
+
+        const targetParentId = getNodeParentId({
+          tree: state.voices.tree,
+          nodeId: payload.positionTargetId,
+        });
+
+        if (targetParentId !== (payload.parentId ?? null)) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a sibling under payload.parentId",
+          );
+        }
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const voiceNodeResult = removeNodeOrResult({
+        tree: state.voices.tree,
+        nodeId: payload.voiceId,
+        errorMessage: "voice move target missing from tree",
+      });
+      if (!voiceNodeResult.valid) {
+        return voiceNodeResult;
+      }
+
+      insertTreeNode({
+        tree: state.voices.tree,
+        node: voiceNodeResult.node,
+        parentId: payload.parentId ?? null,
+        index: payload.index,
+        position: payload.position,
+        positionTargetId: payload.positionTargetId,
+      });
+
+      return state;
+    },
+  },
   {
     type: "video.create",
     validatePayload: ({ payload }) => {