@routevn/creator-model 1.7.3 → 1.8.1

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;
@@ -392,7 +394,7 @@ const LAYOUT_ELEMENT_BASE_TYPES = [
   "container-ref-confirm-dialog-ok",
   "container-ref-confirm-dialog-cancel",
 ];
-export const SCHEMA_VERSION = 7;
+export const SCHEMA_VERSION = 8;
 const LAYOUT_CONTAINER_ELEMENT_TYPES = [
   "folder",
   "container",
@@ -404,6 +406,18 @@ const LAYOUT_CONTAINER_ELEMENT_TYPES = [
   "container-ref-confirm-dialog-ok",
   "container-ref-confirm-dialog-cancel",
 ];
+const LAYOUT_TEXT_CONTENT_ELEMENT_TYPES = [
+  "text",
+  "text-revealing",
+  "text-ref-character-name",
+  "text-revealing-ref-dialogue-content",
+  "text-ref-choice-item-content",
+  "text-ref-save-load-slot-date",
+  "text-ref-dialogue-line-character-name",
+  "text-ref-dialogue-line-content",
+  "text-ref-history-line-character-name",
+  "text-ref-history-line-content",
+];
 const DOMAIN_ERROR_KIND_BY_NAME = {
   PayloadValidationError: "payload",
   PreconditionValidationError: "precondition",
@@ -1431,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}`;
@@ -3419,97 +3532,36 @@ const validateLayoutElementBlur = ({ blur, path, errorFactory }) => {
   }
 };
 
-const validateLayoutElementData = ({
-  data,
+const LAYOUT_TEXT_REVEAL_INDICATOR_ELEMENT_TYPES = [
+  "text-revealing",
+  "text-revealing-ref-dialogue-content",
+];
+
+const validateLayoutTextRevealIndicatorVisual = ({
+  visual,
   path,
   errorFactory,
-  allowPartial = false,
 }) => {
-  if (!isPlainObject(data)) {
-    return invalidFromErrorFactory(errorFactory, `${path} must be an object`);
+  if (!isPlainObject(visual)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path} must be an object when provided`,
+    );
   }
 
-  const allowedKeys = [
-    "type",
-    "name",
-    "x",
-    "y",
-    "width",
-    "height",
-    "aspectRatioLock",
-    "anchorX",
-    "anchorY",
-    "scaleX",
-    "scaleY",
-    "rotation",
-    "opacity",
-    "blur",
-    "fill",
-    "border",
-    "text",
-    "textStyle",
-    "displaySpeed",
-    "revealEffect",
-    "resourceId",
-    "animationName",
-    "imageId",
-    "hoverImageId",
-    "clickImageId",
-    "hoverSoundId",
-    "clickSoundId",
-    "textStyleId",
-    "hoverTextStyleId",
-    "clickTextStyleId",
-    "field",
-    "value",
-    "placeholder",
-    "multiline",
-    "disabled",
-    "maxLength",
-    "formRole",
-    "padding",
-    "conditionalOverrides",
-    "direction",
-    "gapX",
-    "gapY",
-    "containerType",
-    "scroll",
-    "hover",
-    "click",
-    "rightClick",
-    "scrollUp",
-    "scrollDown",
-    "submit",
-    "focusEvent",
-    "blurEvent",
-    "selectionChange",
-    "compositionStart",
-    "compositionUpdate",
-    "compositionEnd",
-    "anchorToBottom",
-    "thumbImageId",
-    "barImageId",
-    "hoverThumbImageId",
-    "hoverBarImageId",
-    "min",
-    "max",
-    "step",
-    "initialValue",
-    "variableId",
-    "particleId",
-    "fragmentLayoutId",
-    "paginationMode",
-    "paginationVariableId",
-    "paginationSize",
-    "choiceItemIndex",
-    "$when",
-    "change",
-  ];
-
   {
     const result = validateAllowedKeys({
-      value: data,
-      allowedKeys,
+      value: visual,
+      allowedKeys: [
+        "kind",
+        "imageId",
+        "resourceId",
+        "animationName",
+        "width",
+        "height",
+        "offsetX",
+        "offsetY",
+      ],
       path,
       errorFactory,
     });
@@ -3518,101 +3570,140 @@ const validateLayoutElementData = ({
     }
   }
 
-  if (!allowPartial || data.type !== undefined) {
-    if (!LAYOUT_ELEMENT_BASE_TYPES.includes(data.type)) {
+  const kind =
+    visual.kind === "spritesheet" ||
+    visual.resourceId !== undefined ||
+    visual.animationName !== undefined
+      ? "spritesheet"
+      : "image";
+
+  if (
+    visual.kind !== undefined &&
+    visual.kind !== "image" &&
+    visual.kind !== "spritesheet"
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.kind must be 'image' or 'spritesheet' when provided`,
+    );
+  }
+
+  if (kind === "image" && !isNonEmptyString(visual.imageId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.imageId must be a non-empty string`,
+    );
+  }
+
+  if (kind === "spritesheet") {
+    if (!isNonEmptyString(visual.resourceId)) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.type must be a supported layout element type`,
+        `${path}.resourceId must be a non-empty string`,
+      );
+    }
+
+    if (!isNonEmptyString(visual.animationName)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.animationName must be a non-empty string`,
       );
     }
   }
 
-  if (!allowPartial || data.name !== undefined) {
-    if (!isNonEmptyString(data.name)) {
+  for (const key of ["width", "height"]) {
+    if (
+      visual[key] !== undefined &&
+      (!isFiniteNumber(visual[key]) || visual[key] <= 0)
+    ) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.name must be a non-empty string`,
+        `${path}.${key} must be a finite number greater than 0 when provided`,
       );
     }
   }
 
-  for (const key of [
-    "x",
-    "y",
-    "width",
-    "height",
-    "anchorX",
-    "anchorY",
-    "scaleX",
-    "scaleY",
-    "rotation",
-    "displaySpeed",
-    "gapX",
-    "gapY",
-    "min",
-    "max",
-    "step",
-    "paginationSize",
-    "choiceItemIndex",
-    "opacity",
-    "maxLength",
-  ]) {
-    if (data[key] !== undefined && !isFiniteNumber(data[key])) {
+  for (const key of ["offsetX", "offsetY"]) {
+    if (visual[key] !== undefined && !isFiniteNumber(visual[key])) {
       return invalidFromErrorFactory(
         errorFactory,
         `${path}.${key} must be a finite number when provided`,
       );
     }
   }
+};
 
-  if (
-    data.choiceItemIndex !== undefined &&
-    (!Number.isInteger(data.choiceItemIndex) ||
-      data.choiceItemIndex < 0 ||
-      data.choiceItemIndex > 19)
-  ) {
+const validateLayoutTextRevealIndicator = ({
+  indicator,
+  path,
+  errorFactory,
+}) => {
+  if (!isPlainObject(indicator)) {
     return invalidFromErrorFactory(
       errorFactory,
-      `${path}.choiceItemIndex must be an integer between 0 and 19 when provided`,
+      `${path} must be an object when provided`,
     );
   }
 
-  if (
-    data.aspectRatioLock !== undefined &&
-    (!isFiniteNumber(data.aspectRatioLock) || data.aspectRatioLock <= 0)
-  ) {
-    return invalidFromErrorFactory(
+  {
+    const result = validateAllowedKeys({
+      value: indicator,
+      allowedKeys: ["revealing", "complete", "offsetX", "offsetY"],
+      path,
       errorFactory,
-      `${path}.aspectRatioLock must be a finite number greater than 0 when provided`,
-    );
+    });
+    if (result?.valid === false) {
+      return result;
+    }
   }
 
-  if (
-    data.initialValue !== undefined &&
-    !isFiniteNumber(data.initialValue) &&
-    !isString(data.initialValue)
-  ) {
-    return invalidFromErrorFactory(
-      errorFactory,
-      `${path}.initialValue must be a finite number or string when provided`,
-    );
+  for (const key of ["revealing", "complete"]) {
+    if (indicator[key] !== undefined) {
+      const result = validateLayoutTextRevealIndicatorVisual({
+        visual: indicator[key],
+        path: `${path}.${key}`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
   }
 
-  if (
-    data.opacity !== undefined &&
-    (!isFiniteNumber(data.opacity) || data.opacity < 0 || data.opacity > 1)
-  ) {
+  for (const key of ["offsetX", "offsetY"]) {
+    if (indicator[key] !== undefined && !isFiniteNumber(indicator[key])) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.${key} must be a finite number when provided`,
+      );
+    }
+  }
+};
+
+const validateLayoutTextContent = ({ content, path, errorFactory }) => {
+  if (!Array.isArray(content)) {
     return invalidFromErrorFactory(
       errorFactory,
-      `${path}.opacity must be a finite number between 0 and 1 when provided`,
+      `${path} must be an array when provided`,
     );
   }
 
-  if (data.blur !== undefined) {
+  for (let index = 0; index < content.length; index += 1) {
+    const item = content[index];
+    const itemPath = `${path}[${index}]`;
+
+    if (!isPlainObject(item)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath} must be an object`,
+      );
+    }
+
     {
-      const result = validateLayoutElementBlur({
-        blur: data.blur,
-        path: `${path}.blur`,
+      const result = validateAllowedKeys({
+        value: item,
+        allowedKeys: ["text", "reference"],
+        path: itemPath,
         errorFactory,
       });
       if (result?.valid === false) {
@@ -3620,19 +3711,107 @@ const validateLayoutElementData = ({
       }
     }
 
-    if (data.type !== undefined && data.type !== "sprite") {
+    const hasText = Object.hasOwn(item, "text");
+    const hasReference = Object.hasOwn(item, "reference");
+
+    if (hasText === hasReference) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.blur can only be provided for sprite elements`,
+        `${itemPath} must include exactly one of text or reference`,
+      );
+    }
+
+    if (hasText) {
+      if (!isString(item.text)) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${itemPath}.text must be a string`,
+        );
+      }
+      continue;
+    }
+
+    if (!isPlainObject(item.reference)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.reference must be an object`,
+      );
+    }
+
+    {
+      const result = validateAllowedKeys({
+        value: item.reference,
+        allowedKeys: ["resourceId"],
+        path: `${itemPath}.reference`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (!isNonEmptyString(item.reference.resourceId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${itemPath}.reference.resourceId must be a non-empty string`,
       );
     }
   }
+};
+
+const getLayoutTextContentReferenceEntries = (content) => {
+  if (!Array.isArray(content)) {
+    return [];
+  }
+
+  const entries = [];
+  for (let index = 0; index < content.length; index += 1) {
+    const resourceId = content[index]?.reference?.resourceId;
+    if (resourceId !== undefined) {
+      entries.push({
+        index,
+        resourceId,
+      });
+    }
+  }
+  return entries;
+};
 
-  for (const key of [
+const validateLayoutElementData = ({
+  data,
+  path,
+  errorFactory,
+  allowPartial = false,
+}) => {
+  if (!isPlainObject(data)) {
+    return invalidFromErrorFactory(errorFactory, `${path} must be an object`);
+  }
+
+  const allowedKeys = [
+    "type",
+    "name",
+    "x",
+    "y",
+    "width",
+    "height",
+    "aspectRatioLock",
+    "anchorX",
+    "anchorY",
+    "scaleX",
+    "scaleY",
+    "rotation",
+    "opacity",
+    "blur",
+    "fill",
+    "border",
     "text",
+    "content",
+    "textStyle",
+    "displaySpeed",
+    "revealEffect",
+    "indicator",
     "resourceId",
     "animationName",
-    "particleId",
     "imageId",
     "hoverImageId",
     "clickImageId",
@@ -3644,79 +3823,306 @@ const validateLayoutElementData = ({
     "field",
     "value",
     "placeholder",
+    "multiline",
+    "disabled",
+    "maxLength",
+    "formRole",
+    "padding",
+    "conditionalOverrides",
+    "direction",
+    "gapX",
+    "gapY",
     "containerType",
-    "variableId",
-    "fragmentLayoutId",
-    "paginationMode",
-    "paginationVariableId",
-    "revealEffect",
+    "scroll",
+    "hover",
+    "click",
+    "rightClick",
+    "scrollUp",
+    "scrollDown",
+    "submit",
+    "focusEvent",
+    "blurEvent",
+    "selectionChange",
+    "compositionStart",
+    "compositionUpdate",
+    "compositionEnd",
+    "anchorToBottom",
     "thumbImageId",
     "barImageId",
     "hoverThumbImageId",
     "hoverBarImageId",
+    "min",
+    "max",
+    "step",
+    "initialValue",
+    "variableId",
+    "particleId",
+    "fragmentLayoutId",
+    "paginationMode",
+    "paginationVariableId",
+    "paginationSize",
+    "choiceItemIndex",
     "$when",
-  ]) {
-    if (data[key] !== undefined && !isString(data[key])) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        `${path}.${key} must be a string when provided`,
-      );
-    }
-  }
+    "change",
+  ];
 
-  if (data.type === "spritesheet-animation") {
-    if (
-      (!allowPartial || data.resourceId !== undefined) &&
-      !isNonEmptyString(data.resourceId)
-    ) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        `${path}.resourceId must be a non-empty string`,
-      );
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys,
+      path,
+      errorFactory,
+    });
+    if (result?.valid === false) {
+      return result;
     }
+  }
 
-    if (
-      (!allowPartial || data.animationName !== undefined) &&
-      !isNonEmptyString(data.animationName)
-    ) {
+  if (!allowPartial || data.type !== undefined) {
+    if (!LAYOUT_ELEMENT_BASE_TYPES.includes(data.type)) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.animationName must be a non-empty string`,
+        `${path}.type must be a supported layout element type`,
       );
     }
   }
 
-  if (data.type === "particle") {
-    if (
-      (!allowPartial || data.particleId !== undefined) &&
-      !isNonEmptyString(data.particleId)
-    ) {
+  if (!allowPartial || data.name !== undefined) {
+    if (!isNonEmptyString(data.name)) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.particleId must be a non-empty string`,
+        `${path}.name must be a non-empty string`,
       );
     }
   }
 
-  if (data.type === "input") {
-    if (
-      (!allowPartial || data.field !== undefined) &&
-      !isNonEmptyString(data.field)
-    ) {
+  for (const key of [
+    "x",
+    "y",
+    "width",
+    "height",
+    "anchorX",
+    "anchorY",
+    "scaleX",
+    "scaleY",
+    "rotation",
+    "displaySpeed",
+    "gapX",
+    "gapY",
+    "min",
+    "max",
+    "step",
+    "paginationSize",
+    "choiceItemIndex",
+    "opacity",
+    "maxLength",
+  ]) {
+    if (data[key] !== undefined && !isFiniteNumber(data[key])) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${path}.field must be a non-empty string`,
+        `${path}.${key} must be a finite number when provided`,
       );
     }
   }
 
-  if (data.conditionalOverrides !== undefined) {
-    if (!Array.isArray(data.conditionalOverrides)) {
-      return invalidFromErrorFactory(
-        errorFactory,
-        `${path}.conditionalOverrides must be an array when provided`,
-      );
-    }
+  if (
+    data.choiceItemIndex !== undefined &&
+    (!Number.isInteger(data.choiceItemIndex) ||
+      data.choiceItemIndex < 0 ||
+      data.choiceItemIndex > 19)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.choiceItemIndex must be an integer between 0 and 19 when provided`,
+    );
+  }
+
+  if (
+    data.aspectRatioLock !== undefined &&
+    (!isFiniteNumber(data.aspectRatioLock) || data.aspectRatioLock <= 0)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.aspectRatioLock must be a finite number greater than 0 when provided`,
+    );
+  }
+
+  if (
+    data.initialValue !== undefined &&
+    !isFiniteNumber(data.initialValue) &&
+    !isString(data.initialValue)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.initialValue must be a finite number or string when provided`,
+    );
+  }
+
+  if (
+    data.opacity !== undefined &&
+    (!isFiniteNumber(data.opacity) || data.opacity < 0 || data.opacity > 1)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${path}.opacity must be a finite number between 0 and 1 when provided`,
+    );
+  }
+
+  if (data.blur !== undefined) {
+    {
+      const result = validateLayoutElementBlur({
+        blur: data.blur,
+        path: `${path}.blur`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (data.type !== undefined && data.type !== "sprite") {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.blur can only be provided for sprite elements`,
+      );
+    }
+  }
+
+  if (data.content !== undefined) {
+    {
+      const result = validateLayoutTextContent({
+        content: data.content,
+        path: `${path}.content`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (
+      data.type !== undefined &&
+      !LAYOUT_TEXT_CONTENT_ELEMENT_TYPES.includes(data.type)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.content can only be provided for text elements`,
+      );
+    }
+  }
+
+  if (data.indicator !== undefined) {
+    {
+      const result = validateLayoutTextRevealIndicator({
+        indicator: data.indicator,
+        path: `${path}.indicator`,
+        errorFactory,
+      });
+      if (result?.valid === false) {
+        return result;
+      }
+    }
+
+    if (
+      data.type !== undefined &&
+      !LAYOUT_TEXT_REVEAL_INDICATOR_ELEMENT_TYPES.includes(data.type)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.indicator can only be provided for text revealing elements`,
+      );
+    }
+  }
+
+  for (const key of [
+    "text",
+    "resourceId",
+    "animationName",
+    "particleId",
+    "imageId",
+    "hoverImageId",
+    "clickImageId",
+    "hoverSoundId",
+    "clickSoundId",
+    "textStyleId",
+    "hoverTextStyleId",
+    "clickTextStyleId",
+    "field",
+    "value",
+    "placeholder",
+    "containerType",
+    "variableId",
+    "fragmentLayoutId",
+    "paginationMode",
+    "paginationVariableId",
+    "revealEffect",
+    "thumbImageId",
+    "barImageId",
+    "hoverThumbImageId",
+    "hoverBarImageId",
+    "$when",
+  ]) {
+    if (data[key] !== undefined && !isString(data[key])) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.${key} must be a string when provided`,
+      );
+    }
+  }
+
+  if (data.type === "spritesheet-animation") {
+    if (
+      (!allowPartial || data.resourceId !== undefined) &&
+      !isNonEmptyString(data.resourceId)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.resourceId must be a non-empty string`,
+      );
+    }
+
+    if (
+      (!allowPartial || data.animationName !== undefined) &&
+      !isNonEmptyString(data.animationName)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.animationName must be a non-empty string`,
+      );
+    }
+  }
+
+  if (data.type === "particle") {
+    if (
+      (!allowPartial || data.particleId !== undefined) &&
+      !isNonEmptyString(data.particleId)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.particleId must be a non-empty string`,
+      );
+    }
+  }
+
+  if (data.type === "input") {
+    if (
+      (!allowPartial || data.field !== undefined) &&
+      !isNonEmptyString(data.field)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.field must be a non-empty string`,
+      );
+    }
+  }
+
+  if (data.conditionalOverrides !== undefined) {
+    if (!Array.isArray(data.conditionalOverrides)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${path}.conditionalOverrides must be an array when provided`,
+      );
+    }
 
     for (let index = 0; index < data.conditionalOverrides.length; index += 1) {
       const rule = data.conditionalOverrides[index];
@@ -4143,9 +4549,11 @@ const validateLayoutElementItems = ({ items, path, errorFactory }) => {
           "fill",
           "border",
           "text",
+          "content",
           "textStyle",
           "displaySpeed",
           "revealEffect",
+          "indicator",
           "resourceId",
           "animationName",
           "particleId",
@@ -6104,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({
@@ -6289,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({
@@ -6809,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;
@@ -7420,15 +7900,16 @@ export const assertInvariants = ({ state }) => {
     elementId,
     targetId,
     animationName,
+    fieldPrefix = "",
   }) => {
     const spritesheet = state.spritesheets?.items?.[targetId];
     if (!isPlainObject(spritesheet) || spritesheet.type === "folder") {
       return invalidInvariant(
-        `${ownerLabel} element resourceId must reference an existing non-folder spritesheet`,
+        `${ownerLabel} element ${fieldPrefix}resourceId must reference an existing non-folder spritesheet`,
         {
           [ownerIdField]: ownerId,
           elementId,
-          field: "resourceId",
+          field: `${fieldPrefix}resourceId`,
           targetId,
         },
       );
@@ -7439,11 +7920,11 @@ export const assertInvariants = ({ state }) => {
       !isPlainObject(spritesheet.animations?.[animationName])
     ) {
       return invalidInvariant(
-        `${ownerLabel} element animationName must reference an existing spritesheet animation`,
+        `${ownerLabel} element ${fieldPrefix}animationName must reference an existing spritesheet animation`,
         {
           [ownerIdField]: ownerId,
           elementId,
-          field: "animationName",
+          field: `${fieldPrefix}animationName`,
           targetId: animationName,
         },
       );
@@ -7542,29 +8023,66 @@ export const assertInvariants = ({ state }) => {
           }
         }
 
-        for (const field of ["hoverSoundId", "clickSoundId"]) {
-          if (element[field] !== undefined) {
-            const result = assertSoundReference({
+        for (const stateName of ["revealing", "complete"]) {
+          const visual = element.indicator?.[stateName];
+          if (
+            visual?.kind === "spritesheet" ||
+            visual?.resourceId !== undefined ||
+            visual?.animationName !== undefined
+          ) {
+            const result = assertSpritesheetAnimationReference({
               ownerIdField,
               ownerId,
               ownerLabel,
               elementId,
-              field,
-              targetId: element[field],
+              targetId: visual.resourceId,
+              animationName: visual.animationName,
+              fieldPrefix: `indicator.${stateName}.`,
             });
             if (!result.valid) {
               return result;
             }
+            continue;
           }
-        }
 
-        for (const field of [
-          "textStyleId",
-          "hoverTextStyleId",
-          "clickTextStyleId",
-        ]) {
-          if (element[field] !== undefined) {
-            const result = assertTextStyleReference({
+          if (visual?.imageId !== undefined) {
+            const result = assertImageReference({
+              ownerIdField,
+              ownerId,
+              ownerLabel,
+              elementId,
+              field: `indicator.${stateName}.imageId`,
+              targetId: visual.imageId,
+            });
+            if (!result.valid) {
+              return result;
+            }
+          }
+        }
+
+        for (const field of ["hoverSoundId", "clickSoundId"]) {
+          if (element[field] !== undefined) {
+            const result = assertSoundReference({
+              ownerIdField,
+              ownerId,
+              ownerLabel,
+              elementId,
+              field,
+              targetId: element[field],
+            });
+            if (!result.valid) {
+              return result;
+            }
+          }
+        }
+
+        for (const field of [
+          "textStyleId",
+          "hoverTextStyleId",
+          "clickTextStyleId",
+        ]) {
+          if (element[field] !== undefined) {
+            const result = assertTextStyleReference({
               ownerIdField,
               ownerId,
               ownerLabel,
@@ -7639,6 +8157,23 @@ export const assertInvariants = ({ state }) => {
           }
         }
 
+        for (const {
+          index,
+          resourceId,
+        } of getLayoutTextContentReferenceEntries(element.content)) {
+          if (!isVariableReferenceTarget(state, resourceId)) {
+            return invalidInvariant(
+              `${ownerLabel} element content.${index}.reference.resourceId must reference an existing non-folder variable`,
+              {
+                [ownerIdField]: ownerId,
+                elementId,
+                field: `content.${index}.reference.resourceId`,
+                targetId: resourceId,
+              },
+            );
+          }
+        }
+
         if (element.variableId !== undefined) {
           const result = assertVariableReference({
             ownerIdField,
@@ -8912,6 +9447,167 @@ const validateSoundUpdateData = ({ data, errorFactory }) => {
   }
 };
 
+const validateVoiceCreateData = ({ data, errorFactory }) => {
+  if (!isPlainObject(data)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data must be an object",
+    );
+  }
+
+  if (data.type !== "folder" && data.type !== "voice") {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.type must be 'folder' or 'voice'",
+    );
+  }
+
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys:
+        data.type === "folder"
+          ? ["type", "name", "description"]
+          : [
+              "type",
+              "name",
+              "description",
+              "sceneId",
+              "fileId",
+              "waveformDataFileId",
+              "duration",
+            ],
+      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 === "voice") {
+    if (!isNonEmptyString(data.sceneId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.sceneId must be a non-empty string",
+      );
+    }
+
+    if (!isNonEmptyString(data.fileId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.fileId must be a non-empty string",
+      );
+    }
+
+    if (
+      data.waveformDataFileId !== undefined &&
+      data.waveformDataFileId !== null &&
+      !isNonEmptyString(data.waveformDataFileId)
+    ) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.waveformDataFileId must be a non-empty string or null when provided",
+      );
+    }
+
+    if (data.duration !== undefined && !isFiniteNumber(data.duration)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        "payload.data.duration must be a finite number",
+      );
+    }
+  }
+};
+
+const validateVoiceUpdateData = ({ data, errorFactory }) => {
+  {
+    const result = validateAllowedKeys({
+      value: data,
+      allowedKeys: [
+        "name",
+        "description",
+        "sceneId",
+        "fileId",
+        "waveformDataFileId",
+        "duration",
+      ],
+      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",
+    );
+  }
+
+  if (data.sceneId !== undefined && !isNonEmptyString(data.sceneId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.sceneId must be a non-empty string when provided",
+    );
+  }
+
+  if (data.fileId !== undefined && !isNonEmptyString(data.fileId)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.fileId must be a non-empty string when provided",
+    );
+  }
+
+  if (
+    data.waveformDataFileId !== undefined &&
+    data.waveformDataFileId !== null &&
+    !isNonEmptyString(data.waveformDataFileId)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.waveformDataFileId must be a non-empty string or null when provided",
+    );
+  }
+
+  if (data.duration !== undefined && !isFiniteNumber(data.duration)) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      "payload.data.duration must be a finite number",
+    );
+  }
+};
+
 const validateVideoCreateData = ({ data, errorFactory }) => {
   if (!isPlainObject(data)) {
     return invalidFromErrorFactory(
@@ -11383,6 +12079,36 @@ const validateVisualElementReferenceTargets = ({
     );
   }
 
+  if (
+    data.indicator !== undefined &&
+    !LAYOUT_TEXT_REVEAL_INDICATOR_ELEMENT_TYPES.includes(data.type)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${ownerLabel} element indicator can only be provided for text revealing elements`,
+      {
+        [ownerIdField]: ownerId,
+        elementId,
+        field: "indicator",
+      },
+    );
+  }
+
+  if (
+    data.content !== undefined &&
+    !LAYOUT_TEXT_CONTENT_ELEMENT_TYPES.includes(data.type)
+  ) {
+    return invalidFromErrorFactory(
+      errorFactory,
+      `${ownerLabel} element content can only be provided for text elements`,
+      {
+        [ownerIdField]: ownerId,
+        elementId,
+        field: "content",
+      },
+    );
+  }
+
   if (
     data.type === "spritesheet-animation" ||
     data.resourceId !== undefined ||
@@ -11483,6 +12209,66 @@ const validateVisualElementReferenceTargets = ({
     }
   }
 
+  for (const stateName of ["revealing", "complete"]) {
+    const visual = data.indicator?.[stateName];
+    if (
+      visual?.kind === "spritesheet" ||
+      visual?.resourceId !== undefined ||
+      visual?.animationName !== undefined
+    ) {
+      const spritesheet = state.spritesheets?.items?.[visual.resourceId];
+      if (!isPlainObject(spritesheet) || spritesheet.type === "folder") {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${ownerLabel} element indicator.${stateName}.resourceId must reference an existing non-folder spritesheet`,
+          {
+            [ownerIdField]: ownerId,
+            elementId,
+            field: `indicator.${stateName}.resourceId`,
+            targetId: visual.resourceId,
+          },
+        );
+      }
+
+      if (
+        !isNonEmptyString(visual.animationName) ||
+        !isPlainObject(spritesheet.animations?.[visual.animationName])
+      ) {
+        return invalidFromErrorFactory(
+          errorFactory,
+          `${ownerLabel} element indicator.${stateName}.animationName must reference an existing spritesheet animation`,
+          {
+            [ownerIdField]: ownerId,
+            elementId,
+            field: `indicator.${stateName}.animationName`,
+            targetId: visual.animationName,
+          },
+        );
+      }
+
+      continue;
+    }
+
+    const imageId = visual?.imageId;
+    if (imageId === undefined) {
+      continue;
+    }
+
+    const image = state.images.items[imageId];
+    if (!isPlainObject(image) || image.type === "folder") {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${ownerLabel} element indicator.${stateName}.imageId must reference an existing non-folder image`,
+        {
+          [ownerIdField]: ownerId,
+          elementId,
+          field: `indicator.${stateName}.imageId`,
+          targetId: imageId,
+        },
+      );
+    }
+  }
+
   if (data.hoverSoundId !== undefined) {
     const sound = state.sounds.items[data.hoverSoundId];
     if (!isPlainObject(sound) || sound.type === "folder") {
@@ -11710,22 +12496,39 @@ const validateVisualElementReferenceTargets = ({
     }
   }
 
-  if (data.variableId !== undefined) {
-    if (!isVariableReferenceTarget(state, data.variableId)) {
+  for (const { index, resourceId } of getLayoutTextContentReferenceEntries(
+    data.content,
+  )) {
+    if (!isVariableReferenceTarget(state, resourceId)) {
       return invalidFromErrorFactory(
         errorFactory,
-        `${ownerLabel} element variableId must reference an existing non-folder variable`,
+        `${ownerLabel} element content.${index}.reference.resourceId must reference an existing non-folder variable`,
         {
           [ownerIdField]: ownerId,
           elementId,
-          variableId: data.variableId,
+          field: `content.${index}.reference.resourceId`,
+          targetId: resourceId,
         },
       );
     }
   }
 
-  if (data.fragmentLayoutId !== undefined) {
-    const fragmentLayout = state.layouts.items[data.fragmentLayoutId];
+  if (data.variableId !== undefined) {
+    if (!isVariableReferenceTarget(state, data.variableId)) {
+      return invalidFromErrorFactory(
+        errorFactory,
+        `${ownerLabel} element variableId must reference an existing non-folder variable`,
+        {
+          [ownerIdField]: ownerId,
+          elementId,
+          variableId: data.variableId,
+        },
+      );
+    }
+  }
+
+  if (data.fragmentLayoutId !== undefined) {
+    const fragmentLayout = state.layouts.items[data.fragmentLayoutId];
     if (
       !isPlainObject(fragmentLayout) ||
       fragmentLayout.type !== "layout" ||
@@ -12385,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;
@@ -12775,31 +13600,425 @@ const COMMAND_DEFINITIONS = [
         return;
       }
 
-      const scene = state.scenes.items[initialSceneId];
-      if (!isPlainObject(scene)) {
-        return invalidPrecondition(
-          "payload.data.initialSceneId must reference an existing scene",
-        );
-      }
+      const scene = state.scenes.items[initialSceneId];
+      if (!isPlainObject(scene)) {
+        return invalidPrecondition(
+          "payload.data.initialSceneId must reference an existing scene",
+        );
+      }
+
+      if (scene.type === "folder") {
+        return invalidPrecondition(
+          "payload.data.initialSceneId must reference a non-folder scene",
+        );
+      }
+    },
+    reduce: ({ state, payload }) => {
+      state.story.initialSceneId = payload.data.initialSceneId;
+      return state;
+    },
+  },
+  {
+    type: "scene.create",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateAllowedKeys({
+          value: payload,
+          allowedKeys: [
+            "sceneId",
+            "parentId",
+            "data",
+            "index",
+            "position",
+            "positionTargetId",
+          ],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.sceneId)) {
+        return invalidPayload("payload.sceneId 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 = validateSceneCreateData({
+          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 (Object.hasOwn(state.scenes.items, payload.sceneId)) {
+        return invalidPrecondition("payload.sceneId must not already exist");
+      }
+
+      const parentId = payload.parentId ?? null;
+
+      if (parentId !== null) {
+        const parentScene = state.scenes.items[parentId];
+        if (!isPlainObject(parentScene)) {
+          return invalidPrecondition(
+            "payload.parentId must reference an existing scene",
+          );
+        }
+
+        if (parentScene.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder scene",
+          );
+        }
+      }
+
+      if (payload.positionTargetId !== undefined) {
+        if (!isPlainObject(state.scenes.items[payload.positionTargetId])) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing scene",
+          );
+        }
+
+        const targetParentId =
+          findTreeParentId({
+            nodes: state.scenes.tree,
+            nodeId: payload.positionTargetId,
+          }) ?? null;
+
+        if (targetParentId !== parentId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a sibling under payload.parentId",
+          );
+        }
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const nextScene = {
+        id: payload.sceneId,
+        type: payload.data.type ?? "scene",
+        name: payload.data.name,
+      };
+
+      if (payload.data.description !== undefined) {
+        nextScene.description = payload.data.description;
+      }
+
+      if (nextScene.type === "scene") {
+        nextScene.sections = createEmptyNestedCollection();
+      }
+
+      if (payload.data.position !== undefined) {
+        nextScene.position = structuredClone(payload.data.position);
+      }
+
+      state.scenes.items[payload.sceneId] = nextScene;
+
+      insertTreeNode({
+        tree: state.scenes.tree,
+        node: {
+          id: payload.sceneId,
+          children: [],
+        },
+        parentId: payload.parentId ?? null,
+        index: payload.index,
+        position: payload.position,
+        positionTargetId: payload.positionTargetId,
+      });
+
+      return state;
+    },
+  },
+  {
+    type: "scene.update",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateExactKeys({
+          value: payload,
+          expectedKeys: ["sceneId", "data"],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.sceneId)) {
+        return invalidPayload("payload.sceneId must be a non-empty string");
+      }
+
+      {
+        const result = validateSceneUpdateData({
+          data: payload.data,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      if (!isPlainObject(state.scenes.items[payload.sceneId])) {
+        return invalidPrecondition(
+          "payload.sceneId must reference an existing scene",
+        );
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const currentScene = state.scenes.items[payload.sceneId];
+      const nextScene = structuredClone(currentScene);
+
+      if (payload.data.name !== undefined) {
+        nextScene.name = payload.data.name;
+      }
+
+      if (payload.data.description !== undefined) {
+        nextScene.description = payload.data.description;
+      }
+
+      if (payload.data.position !== undefined) {
+        nextScene.position = {
+          ...(isPlainObject(nextScene.position) ? nextScene.position : {}),
+          ...structuredClone(payload.data.position),
+        };
+      }
+
+      state.scenes.items[payload.sceneId] = nextScene;
+      return state;
+    },
+  },
+  {
+    type: "scene.delete",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateExactKeys({
+          value: payload,
+          expectedKeys: ["sceneIds"],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      {
+        const result = validateRequiredUniqueIdArray({
+          value: payload.sceneIds,
+          path: "payload.sceneIds",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      for (const sceneId of payload.sceneIds) {
+        if (!isPlainObject(state.scenes.items[sceneId])) {
+          return invalidPrecondition(
+            "payload.sceneIds must reference existing scenes",
+            { sceneId },
+          );
+        }
+      }
+    },
+    reduce: ({ state, payload }) => {
+      const deletedSceneIds = new Set();
+
+      for (const sceneId of payload.sceneIds) {
+        const removedNode = removeTreeNode({
+          nodes: state.scenes.tree,
+          nodeId: sceneId,
+        });
+
+        if (!removedNode) {
+          continue;
+        }
+
+        for (const id of collectTreeDescendantIds({ node: removedNode })) {
+          deletedSceneIds.add(id);
+        }
+      }
+
+      for (const sceneId of deletedSceneIds) {
+        delete state.scenes.items[sceneId];
+      }
+
+      if (
+        state.story.initialSceneId !== null &&
+        !isPlainObject(state.scenes.items[state.story.initialSceneId])
+      ) {
+        state.story.initialSceneId = findFirstNonFolderSceneId({ state });
+      }
+
+      return state;
+    },
+  },
+  {
+    type: "scene.move",
+    validatePayload: ({ payload }) => {
+      {
+        const result = validateAllowedKeys({
+          value: payload,
+          allowedKeys: [
+            "sceneId",
+            "parentId",
+            "index",
+            "position",
+            "positionTargetId",
+          ],
+          path: "payload",
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (!isNonEmptyString(payload.sceneId)) {
+        return invalidPayload("payload.sceneId 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 scene = state.scenes.items[payload.sceneId];
+      if (!isPlainObject(scene)) {
+        return invalidPrecondition(
+          "payload.sceneId must reference an existing scene",
+        );
+      }
+
+      const sceneNode = findTreeNode({
+        nodes: state.scenes.tree,
+        nodeId: payload.sceneId,
+      });
+
+      if (payload.parentId !== undefined && payload.parentId !== null) {
+        const parentScene = state.scenes.items[payload.parentId];
+        if (!isPlainObject(parentScene)) {
+          return invalidPrecondition(
+            "payload.parentId must reference an existing scene",
+          );
+        }
+
+        if (parentScene.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder scene",
+          );
+        }
+
+        const descendantIds = new Set(
+          collectTreeDescendantIds({
+            node: sceneNode,
+          }),
+        );
+
+        if (descendantIds.has(payload.parentId)) {
+          return invalidPrecondition(
+            "payload.parentId must not target the moved scene or its descendants",
+          );
+        }
+      }
+
+      if (payload.positionTargetId !== undefined) {
+        if (payload.positionTargetId === payload.sceneId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must not reference the moved scene",
+          );
+        }
+
+        if (!isPlainObject(state.scenes.items[payload.positionTargetId])) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing scene",
+          );
+        }
+
+        const targetParentId = getNodeParentId({
+          tree: state.scenes.tree,
+          nodeId: payload.positionTargetId,
+        });
 
-      if (scene.type === "folder") {
-        return invalidPrecondition(
-          "payload.data.initialSceneId must reference a non-folder scene",
-        );
+        if (targetParentId !== (payload.parentId ?? null)) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a sibling under payload.parentId",
+          );
+        }
       }
     },
     reduce: ({ state, payload }) => {
-      state.story.initialSceneId = payload.data.initialSceneId;
+      const sceneNodeResult = removeNodeOrResult({
+        tree: state.scenes.tree,
+        nodeId: payload.sceneId,
+        errorMessage: "scene move target missing from tree",
+      });
+      if (!sceneNodeResult.valid) {
+        return sceneNodeResult;
+      }
+
+      insertTreeNode({
+        tree: state.scenes.tree,
+        node: sceneNodeResult.node,
+        parentId: payload.parentId ?? null,
+        index: payload.index,
+        position: payload.position,
+        positionTargetId: payload.positionTargetId,
+      });
+
       return state;
     },
   },
   {
-    type: "scene.create",
+    type: "section.create",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
+            "sectionId",
             "sceneId",
             "parentId",
             "data",
@@ -12815,6 +14034,10 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
+      if (!isNonEmptyString(payload.sectionId)) {
+        return invalidPayload("payload.sectionId must be a non-empty string");
+      }
+
       if (!isNonEmptyString(payload.sceneId)) {
         return invalidPayload("payload.sceneId must be a non-empty string");
       }
@@ -12830,7 +14053,7 @@ const COMMAND_DEFINITIONS = [
       }
 
       {
-        const result = validateSceneCreateData({
+        const result = validateSectionCreateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -12850,41 +14073,65 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      if (Object.hasOwn(state.scenes.items, payload.sceneId)) {
-        return invalidPrecondition("payload.sceneId must not already exist");
+      const scene = state.scenes.items[payload.sceneId];
+      if (!isPlainObject(scene)) {
+        return invalidPrecondition(
+          "payload.sceneId must reference an existing scene",
+        );
       }
 
-      const parentId = payload.parentId ?? null;
+      if (scene.type === "folder") {
+        return invalidPrecondition(
+          "payload.sceneId must reference a non-folder scene",
+        );
+      }
 
-      if (parentId !== null) {
-        const parentScene = state.scenes.items[parentId];
-        if (!isPlainObject(parentScene)) {
+      if (findSectionLocation({ state, sectionId: payload.sectionId })) {
+        return invalidPrecondition("payload.sectionId must not already exist");
+      }
+
+      if (payload.parentId !== undefined && payload.parentId !== null) {
+        const parentLocation = findSectionLocation({
+          state,
+          sectionId: payload.parentId,
+        });
+        if (!parentLocation) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing scene",
+            "payload.parentId must reference an existing section",
           );
         }
 
-        if (parentScene.type !== "folder") {
+        if (parentLocation.sceneId !== payload.sceneId) {
           return invalidPrecondition(
-            "payload.parentId must reference a folder scene",
+            "payload.parentId must reference a section in the same scene",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (!isPlainObject(state.scenes.items[payload.positionTargetId])) {
+        const targetLocation = findSectionLocation({
+          state,
+          sectionId: payload.positionTargetId,
+        });
+        if (!targetLocation) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing scene",
+            "payload.positionTargetId must reference an existing section",
           );
         }
 
-        const targetParentId =
-          findTreeParentId({
-            nodes: state.scenes.tree,
-            nodeId: payload.positionTargetId,
-          }) ?? null;
+        if (targetLocation.sceneId !== payload.sceneId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a section in the same scene",
+          );
+        }
 
-        if (targetParentId !== parentId) {
+        const sections = scene.sections ?? createEmptyNestedCollection();
+        const targetParentId = getNodeParentId({
+          tree: sections.tree,
+          nodeId: payload.positionTargetId,
+        });
+
+        if (targetParentId !== (payload.parentId ?? null)) {
           return invalidPrecondition(
             "payload.positionTargetId must reference a sibling under payload.parentId",
           );
@@ -12892,30 +14139,19 @@ const COMMAND_DEFINITIONS = [
       }
     },
     reduce: ({ state, payload }) => {
-      const nextScene = {
-        id: payload.sceneId,
-        type: payload.data.type ?? "scene",
+      const scene = state.scenes.items[payload.sceneId];
+      scene.sections ??= createEmptyNestedCollection();
+      const sections = scene.sections;
+      sections.items[payload.sectionId] = {
+        id: payload.sectionId,
         name: payload.data.name,
+        lines: createEmptyNestedCollection(),
       };
 
-      if (payload.data.description !== undefined) {
-        nextScene.description = payload.data.description;
-      }
-
-      if (nextScene.type === "scene") {
-        nextScene.sections = createEmptyNestedCollection();
-      }
-
-      if (payload.data.position !== undefined) {
-        nextScene.position = structuredClone(payload.data.position);
-      }
-
-      state.scenes.items[payload.sceneId] = nextScene;
-
       insertTreeNode({
-        tree: state.scenes.tree,
+        tree: sections.tree,
         node: {
-          id: payload.sceneId,
+          id: payload.sectionId,
           children: [],
         },
         parentId: payload.parentId ?? null,
@@ -12928,12 +14164,12 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "scene.update",
+    type: "section.update",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["sceneId", "data"],
+          expectedKeys: ["sectionId", "data"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -12942,12 +14178,12 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.sceneId)) {
-        return invalidPayload("payload.sceneId must be a non-empty string");
+      if (!isNonEmptyString(payload.sectionId)) {
+        return invalidPayload("payload.sectionId must be a non-empty string");
       }
 
       {
-        const result = validateSceneUpdateData({
+        const result = validateSectionUpdateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -12957,42 +14193,32 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      if (!isPlainObject(state.scenes.items[payload.sceneId])) {
+      if (!findSectionLocation({ state, sectionId: payload.sectionId })) {
         return invalidPrecondition(
-          "payload.sceneId must reference an existing scene",
+          "payload.sectionId must reference an existing section",
         );
       }
     },
     reduce: ({ state, payload }) => {
-      const currentScene = state.scenes.items[payload.sceneId];
-      const nextScene = structuredClone(currentScene);
-
-      if (payload.data.name !== undefined) {
-        nextScene.name = payload.data.name;
-      }
-
-      if (payload.data.description !== undefined) {
-        nextScene.description = payload.data.description;
-      }
-
-      if (payload.data.position !== undefined) {
-        nextScene.position = {
-          ...(isPlainObject(nextScene.position) ? nextScene.position : {}),
-          ...structuredClone(payload.data.position),
-        };
-      }
-
-      state.scenes.items[payload.sceneId] = nextScene;
+      const location = findSectionLocation({
+        state,
+        sectionId: payload.sectionId,
+      });
+      const section = location.section;
+      location.sections.items[payload.sectionId] = {
+        ...section,
+        name: payload.data.name,
+      };
       return state;
     },
   },
   {
-    type: "scene.delete",
+    type: "section.delete",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["sceneIds"],
+          expectedKeys: ["sectionIds"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -13003,8 +14229,8 @@ const COMMAND_DEFINITIONS = [
 
       {
         const result = validateRequiredUniqueIdArray({
-          value: payload.sceneIds,
-          path: "payload.sceneIds",
+          value: payload.sectionIds,
+          path: "payload.sectionIds",
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13013,54 +14239,66 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      for (const sceneId of payload.sceneIds) {
-        if (!isPlainObject(state.scenes.items[sceneId])) {
+      for (const sectionId of payload.sectionIds) {
+        if (!findSectionLocation({ state, sectionId })) {
           return invalidPrecondition(
-            "payload.sceneIds must reference existing scenes",
-            { sceneId },
+            "payload.sectionIds must reference existing sections",
+            { sectionId },
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const deletedSceneIds = new Set();
+      const deletedSectionIdsByScene = new Map();
+
+      for (const sectionId of payload.sectionIds) {
+        const location = findSectionLocation({ state, sectionId });
+        if (!location) {
+          continue;
+        }
 
-      for (const sceneId of payload.sceneIds) {
         const removedNode = removeTreeNode({
-          nodes: state.scenes.tree,
-          nodeId: sceneId,
+          nodes: location.sections.tree,
+          nodeId: sectionId,
         });
 
         if (!removedNode) {
           continue;
         }
 
+        let deletedSectionIds = deletedSectionIdsByScene.get(location.sceneId);
+        if (!deletedSectionIds) {
+          deletedSectionIds = new Set();
+          deletedSectionIdsByScene.set(location.sceneId, deletedSectionIds);
+        }
+
         for (const id of collectTreeDescendantIds({ node: removedNode })) {
-          deletedSceneIds.add(id);
+          deletedSectionIds.add(id);
         }
       }
 
-      for (const sceneId of deletedSceneIds) {
-        delete state.scenes.items[sceneId];
-      }
+      for (const [sceneId, deletedSectionIds] of deletedSectionIdsByScene) {
+        const sections = state.scenes.items[sceneId]?.sections;
+        if (!sections) {
+          continue;
+        }
 
-      if (
-        state.story.initialSceneId !== null &&
-        !isPlainObject(state.scenes.items[state.story.initialSceneId])
-      ) {
-        state.story.initialSceneId = findFirstNonFolderSceneId({ state });
+        for (const sectionId of deletedSectionIds) {
+          delete sections.items[sectionId];
+        }
       }
 
       return state;
     },
   },
   {
-    type: "scene.move",
+    type: "section.move",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
+            "sectionId",
             "sceneId",
             "parentId",
             "index",
@@ -13075,8 +14313,14 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.sceneId)) {
-        return invalidPayload("payload.sceneId must be a non-empty string");
+      if (!isNonEmptyString(payload.sectionId)) {
+        return invalidPayload("payload.sectionId must be a non-empty string");
+      }
+
+      if (payload.sceneId !== undefined && !isNonEmptyString(payload.sceneId)) {
+        return invalidPayload(
+          "payload.sceneId must be a non-empty string when provided",
+        );
       }
 
       if (
@@ -13100,60 +14344,108 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const scene = state.scenes.items[payload.sceneId];
-      if (!isPlainObject(scene)) {
+      const location = findSectionLocation({
+        state,
+        sectionId: payload.sectionId,
+      });
+      if (!location) {
+        return invalidPrecondition(
+          "payload.sectionId must reference an existing section",
+        );
+      }
+
+      const targetSceneId = payload.sceneId ?? location.sceneId;
+      const targetScene = state.scenes.items[targetSceneId];
+      if (!isPlainObject(targetScene)) {
         return invalidPrecondition(
           "payload.sceneId must reference an existing scene",
         );
       }
 
-      const sceneNode = findTreeNode({
-        nodes: state.scenes.tree,
-        nodeId: payload.sceneId,
+      if (targetScene.type !== "scene") {
+        return invalidPrecondition(
+          "payload.sceneId must reference a non-folder scene",
+        );
+      }
+
+      const targetSections =
+        targetScene.sections ?? createEmptyNestedCollection();
+      const sectionNode = findTreeNode({
+        nodes: location.sections.tree,
+        nodeId: payload.sectionId,
       });
+      const isCrossSceneMove = targetSceneId !== location.sceneId;
+
+      if (isCrossSceneMove) {
+        const sourceSectionCount = Object.keys(
+          location.sections?.items ?? {},
+        ).length;
+        const movedSectionCount = collectTreeDescendantIds({
+          node: sectionNode,
+        }).length;
+
+        if (sourceSectionCount <= movedSectionCount) {
+          return invalidPrecondition(
+            "payload.sectionId must not move the last section out of a scene",
+          );
+        }
+      }
 
       if (payload.parentId !== undefined && payload.parentId !== null) {
-        const parentScene = state.scenes.items[payload.parentId];
-        if (!isPlainObject(parentScene)) {
+        const parentLocation = findSectionLocation({
+          state,
+          sectionId: payload.parentId,
+        });
+        if (!parentLocation) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing scene",
+            "payload.parentId must reference an existing section",
           );
         }
 
-        if (parentScene.type !== "folder") {
+        if (parentLocation.sceneId !== targetSceneId) {
           return invalidPrecondition(
-            "payload.parentId must reference a folder scene",
+            "payload.parentId must reference a section in the target scene",
           );
         }
 
         const descendantIds = new Set(
           collectTreeDescendantIds({
-            node: sceneNode,
+            node: sectionNode,
           }),
         );
 
         if (descendantIds.has(payload.parentId)) {
           return invalidPrecondition(
-            "payload.parentId must not target the moved scene or its descendants",
+            "payload.parentId must not target the moved section or its descendants",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (payload.positionTargetId === payload.sceneId) {
+        if (payload.positionTargetId === payload.sectionId) {
           return invalidPrecondition(
-            "payload.positionTargetId must not reference the moved scene",
+            "payload.positionTargetId must not reference the moved section",
           );
         }
 
-        if (!isPlainObject(state.scenes.items[payload.positionTargetId])) {
+        const targetLocation = findSectionLocation({
+          state,
+          sectionId: payload.positionTargetId,
+        });
+        if (!targetLocation) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing scene",
+            "payload.positionTargetId must reference an existing section",
+          );
+        }
+
+        if (targetLocation.sceneId !== targetSceneId) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference a section in the target scene",
           );
         }
 
         const targetParentId = getNodeParentId({
-          tree: state.scenes.tree,
+          tree: targetSections.tree,
           nodeId: payload.positionTargetId,
         });
 
@@ -13165,18 +14457,38 @@ const COMMAND_DEFINITIONS = [
       }
     },
     reduce: ({ state, payload }) => {
-      const sceneNodeResult = removeNodeOrResult({
-        tree: state.scenes.tree,
-        nodeId: payload.sceneId,
-        errorMessage: "scene move target missing from tree",
+      const location = findSectionLocation({
+        state,
+        sectionId: payload.sectionId,
       });
-      if (!sceneNodeResult.valid) {
-        return sceneNodeResult;
+      const targetSceneId = payload.sceneId ?? location.sceneId;
+      const targetScene = state.scenes.items[targetSceneId];
+      targetScene.sections ??= createEmptyNestedCollection();
+      const targetSections = targetScene.sections;
+      const sectionNodeResult = removeNodeOrResult({
+        tree: location.sections.tree,
+        nodeId: payload.sectionId,
+        errorMessage: "section move target missing from tree",
+      });
+      if (!sectionNodeResult.valid) {
+        return sectionNodeResult;
+      }
+
+      if (targetSections !== location.sections) {
+        const movedSectionIds = collectTreeDescendantIds({
+          node: sectionNodeResult.node,
+        });
+
+        for (const movedSectionId of movedSectionIds) {
+          targetSections.items[movedSectionId] =
+            location.sections.items[movedSectionId];
+          delete location.sections.items[movedSectionId];
+        }
       }
 
       insertTreeNode({
-        tree: state.scenes.tree,
-        node: sceneNodeResult.node,
+        tree: targetSections.tree,
+        node: sectionNodeResult.node,
         parentId: payload.parentId ?? null,
         index: payload.index,
         position: payload.position,
@@ -13187,16 +14499,14 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "section.create",
+    type: "line.create",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
             "sectionId",
-            "sceneId",
-            "parentId",
-            "data",
+            "lines",
             "index",
             "position",
             "positionTargetId",
@@ -13213,23 +14523,9 @@ const COMMAND_DEFINITIONS = [
         return invalidPayload("payload.sectionId must be a non-empty string");
       }
 
-      if (!isNonEmptyString(payload.sceneId)) {
-        return invalidPayload("payload.sceneId 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 = validateSectionCreateData({
-          data: payload.data,
+        const result = validateLineCreatePayload({
+          payload,
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13248,103 +14544,82 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const scene = state.scenes.items[payload.sceneId];
-      if (!isPlainObject(scene)) {
-        return invalidPrecondition(
-          "payload.sceneId must reference an existing scene",
-        );
-      }
-
-      if (scene.type === "folder") {
+      const sectionLocation = findSectionLocation({
+        state,
+        sectionId: payload.sectionId,
+      });
+      if (!sectionLocation) {
         return invalidPrecondition(
-          "payload.sceneId must reference a non-folder scene",
+          "payload.sectionId must reference an existing section",
         );
       }
 
-      if (findSectionLocation({ state, sectionId: payload.sectionId })) {
-        return invalidPrecondition("payload.sectionId must not already exist");
-      }
-
-      if (payload.parentId !== undefined && payload.parentId !== null) {
-        const parentLocation = findSectionLocation({
-          state,
-          sectionId: payload.parentId,
-        });
-        if (!parentLocation) {
-          return invalidPrecondition(
-            "payload.parentId must reference an existing section",
-          );
-        }
-
-        if (parentLocation.sceneId !== payload.sceneId) {
+      for (const item of payload.lines) {
+        if (findLineLocation({ state, lineId: item.lineId })) {
           return invalidPrecondition(
-            "payload.parentId must reference a section in the same scene",
+            "payload.lines.lineId must not already exist",
+            { lineId: item.lineId },
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        const targetLocation = findSectionLocation({
+        const targetLocation = findLineLocation({
           state,
-          sectionId: payload.positionTargetId,
+          lineId: payload.positionTargetId,
         });
         if (!targetLocation) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing section",
-          );
-        }
-
-        if (targetLocation.sceneId !== payload.sceneId) {
-          return invalidPrecondition(
-            "payload.positionTargetId must reference a section in the same scene",
+            "payload.positionTargetId must reference an existing line",
           );
         }
 
-        const sections = scene.sections ?? createEmptyNestedCollection();
-        const targetParentId = getNodeParentId({
-          tree: sections.tree,
-          nodeId: payload.positionTargetId,
-        });
-
-        if (targetParentId !== (payload.parentId ?? null)) {
+        if (targetLocation.sectionId !== payload.sectionId) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference a sibling under payload.parentId",
+            "payload.positionTargetId must reference a line in the target section",
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const scene = state.scenes.items[payload.sceneId];
-      scene.sections ??= createEmptyNestedCollection();
-      const sections = scene.sections;
-      sections.items[payload.sectionId] = {
-        id: payload.sectionId,
-        name: payload.data.name,
-        lines: createEmptyNestedCollection(),
-      };
+      const sectionLocation = findSectionLocation({
+        state,
+        sectionId: payload.sectionId,
+      });
+      sectionLocation.section.lines ??= createEmptyNestedCollection();
+      const lines = sectionLocation.section.lines;
+      let previousLineId = payload.positionTargetId;
 
-      insertTreeNode({
-        tree: sections.tree,
-        node: {
-          id: payload.sectionId,
-          children: [],
-        },
-        parentId: payload.parentId ?? null,
-        index: payload.index,
-        position: payload.position,
-        positionTargetId: payload.positionTargetId,
+      payload.lines.forEach((item, index) => {
+        lines.items[item.lineId] = {
+          id: item.lineId,
+          actions: structuredClone(item.data.actions || {}),
+        };
+
+        insertTreeNode({
+          tree: lines.tree,
+          node: { id: item.lineId },
+          index: Number.isInteger(payload.index)
+            ? payload.index + index
+            : undefined,
+          position: index === 0 ? payload.position : "after",
+          positionTargetId:
+            index === 0 ? payload.positionTargetId : previousLineId,
+        });
+
+        previousLineId = item.lineId;
       });
 
       return state;
     },
   },
   {
-    type: "section.update",
+    type: "line.update_actions",
     validatePayload: ({ payload }) => {
       {
-        const result = validateExactKeys({
+        const result = validateAllowedKeys({
           value: payload,
-          expectedKeys: ["sectionId", "data"],
+          allowedKeys: ["lineId", "data", "replace", "preserve"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -13353,13 +14628,34 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.sectionId)) {
-        return invalidPayload("payload.sectionId must be a non-empty string");
+      if (!isNonEmptyString(payload.lineId)) {
+        return invalidPayload("payload.lineId must be a non-empty string");
+      }
+
+      {
+        const result = validateLineUpdateActionsData({
+          data: payload.data,
+          errorFactory: createPayloadValidationError,
+        });
+        if (result?.valid === false) {
+          return result;
+        }
+      }
+
+      if (
+        payload.replace !== undefined &&
+        typeof payload.replace !== "boolean"
+      ) {
+        return invalidPayload(
+          "payload.replace must be a boolean when provided",
+        );
       }
 
       {
-        const result = validateSectionUpdateData({
+        const result = validateLineUpdateActionsPreserve({
+          preserve: payload.preserve,
           data: payload.data,
+          replace: payload.replace,
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13368,32 +14664,37 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      if (!findSectionLocation({ state, sectionId: payload.sectionId })) {
+      if (!findLineLocation({ state, lineId: payload.lineId })) {
         return invalidPrecondition(
-          "payload.sectionId must reference an existing section",
+          "payload.lineId must reference an existing line",
         );
       }
     },
     reduce: ({ state, payload }) => {
-      const location = findSectionLocation({
-        state,
-        sectionId: payload.sectionId,
+      const location = findLineLocation({ state, lineId: payload.lineId });
+      const line = location.line;
+      const nextData = applyLineUpdateActionsPreserve({
+        currentActions: line.actions,
+        data: payload.data,
+        preserve: payload.preserve,
       });
-      const section = location.section;
-      location.sections.items[payload.sectionId] = {
-        ...section,
-        name: payload.data.name,
-      };
+      line.actions =
+        payload.replace === true
+          ? structuredClone(nextData)
+          : {
+              ...structuredClone(line.actions),
+              ...structuredClone(nextData),
+            };
       return state;
     },
   },
   {
-    type: "section.delete",
+    type: "line.delete",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["sectionIds"],
+          expectedKeys: ["lineIds"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -13404,8 +14705,8 @@ const COMMAND_DEFINITIONS = [
 
       {
         const result = validateRequiredUniqueIdArray({
-          value: payload.sectionIds,
-          path: "payload.sectionIds",
+          value: payload.lineIds,
+          path: "payload.lineIds",
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13414,68 +14715,38 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      for (const sectionId of payload.sectionIds) {
-        if (!findSectionLocation({ state, sectionId })) {
+      for (const lineId of payload.lineIds) {
+        if (!findLineLocation({ state, lineId })) {
           return invalidPrecondition(
-            "payload.sectionIds must reference existing sections",
-            { sectionId },
+            "payload.lineIds must reference existing lines",
+            { lineId },
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const deletedSectionIdsByScene = new Map();
-
-      for (const sectionId of payload.sectionIds) {
-        const location = findSectionLocation({ state, sectionId });
-        if (!location) {
-          continue;
-        }
-
-        const removedNode = removeTreeNode({
-          nodes: location.sections.tree,
-          nodeId: sectionId,
+      for (const lineId of payload.lineIds) {
+        const location = findLineLocation({ state, lineId });
+        location.section.lines ??= createEmptyNestedCollection();
+        delete location.section.lines.items[lineId];
+        removeTreeNode({
+          nodes: location.section.lines.tree,
+          nodeId: lineId,
         });
-
-        if (!removedNode) {
-          continue;
-        }
-
-        let deletedSectionIds = deletedSectionIdsByScene.get(location.sceneId);
-        if (!deletedSectionIds) {
-          deletedSectionIds = new Set();
-          deletedSectionIdsByScene.set(location.sceneId, deletedSectionIds);
-        }
-
-        for (const id of collectTreeDescendantIds({ node: removedNode })) {
-          deletedSectionIds.add(id);
-        }
-      }
-
-      for (const [sceneId, deletedSectionIds] of deletedSectionIdsByScene) {
-        const sections = state.scenes.items[sceneId]?.sections;
-        if (!sections) {
-          continue;
-        }
-
-        for (const sectionId of deletedSectionIds) {
-          delete sections.items[sectionId];
-        }
       }
 
       return state;
     },
   },
   {
-    type: "section.move",
+    type: "line.move",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "sectionId",
-            "sceneId",
-            "parentId",
+            "lineId",
+            "toSectionId",
             "index",
             "position",
             "positionTargetId",
@@ -13488,24 +14759,12 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.sectionId)) {
-        return invalidPayload("payload.sectionId must be a non-empty string");
-      }
-
-      if (payload.sceneId !== undefined && !isNonEmptyString(payload.sceneId)) {
-        return invalidPayload(
-          "payload.sceneId must be a non-empty string when provided",
-        );
+      if (!isNonEmptyString(payload.lineId)) {
+        return invalidPayload("payload.lineId 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",
-        );
+      if (!isNonEmptyString(payload.toSectionId)) {
+        return invalidPayload("payload.toSectionId must be a non-empty string");
       }
 
       {
@@ -13519,152 +14778,78 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const location = findSectionLocation({
+      const lineLocation = findLineLocation({
         state,
-        sectionId: payload.sectionId,
+        lineId: payload.lineId,
       });
-      if (!location) {
-        return invalidPrecondition(
-          "payload.sectionId must reference an existing section",
-        );
-      }
-
-      const targetSceneId = payload.sceneId ?? location.sceneId;
-      const targetScene = state.scenes.items[targetSceneId];
-      if (!isPlainObject(targetScene)) {
-        return invalidPrecondition(
-          "payload.sceneId must reference an existing scene",
-        );
-      }
-
-      if (targetScene.type !== "scene") {
+      if (!lineLocation) {
         return invalidPrecondition(
-          "payload.sceneId must reference a non-folder scene",
+          "payload.lineId must reference an existing line",
         );
       }
 
-      const targetSections =
-        targetScene.sections ?? createEmptyNestedCollection();
-      const sectionNode = findTreeNode({
-        nodes: location.sections.tree,
-        nodeId: payload.sectionId,
+      const targetSectionLocation = findSectionLocation({
+        state,
+        sectionId: payload.toSectionId,
       });
-      const isCrossSceneMove = targetSceneId !== location.sceneId;
-
-      if (isCrossSceneMove) {
-        const sourceSectionCount = Object.keys(
-          location.sections?.items ?? {},
-        ).length;
-        const movedSectionCount = collectTreeDescendantIds({
-          node: sectionNode,
-        }).length;
-
-        if (sourceSectionCount <= movedSectionCount) {
-          return invalidPrecondition(
-            "payload.sectionId must not move the last section out of a scene",
-          );
-        }
-      }
-
-      if (payload.parentId !== undefined && payload.parentId !== null) {
-        const parentLocation = findSectionLocation({
-          state,
-          sectionId: payload.parentId,
-        });
-        if (!parentLocation) {
-          return invalidPrecondition(
-            "payload.parentId must reference an existing section",
-          );
-        }
-
-        if (parentLocation.sceneId !== targetSceneId) {
-          return invalidPrecondition(
-            "payload.parentId must reference a section in the target scene",
-          );
-        }
-
-        const descendantIds = new Set(
-          collectTreeDescendantIds({
-            node: sectionNode,
-          }),
+      if (!targetSectionLocation) {
+        return invalidPrecondition(
+          "payload.toSectionId must reference an existing section",
         );
-
-        if (descendantIds.has(payload.parentId)) {
-          return invalidPrecondition(
-            "payload.parentId must not target the moved section or its descendants",
-          );
-        }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (payload.positionTargetId === payload.sectionId) {
+        if (payload.positionTargetId === payload.lineId) {
           return invalidPrecondition(
-            "payload.positionTargetId must not reference the moved section",
+            "payload.positionTargetId must not reference the moved line",
           );
         }
 
-        const targetLocation = findSectionLocation({
+        const targetLocation = findLineLocation({
           state,
-          sectionId: payload.positionTargetId,
+          lineId: payload.positionTargetId,
         });
         if (!targetLocation) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing section",
-          );
-        }
-
-        if (targetLocation.sceneId !== targetSceneId) {
-          return invalidPrecondition(
-            "payload.positionTargetId must reference a section in the target scene",
+            "payload.positionTargetId must reference an existing line",
           );
         }
 
-        const targetParentId = getNodeParentId({
-          tree: targetSections.tree,
-          nodeId: payload.positionTargetId,
-        });
-
-        if (targetParentId !== (payload.parentId ?? null)) {
+        if (targetLocation.sectionId !== payload.toSectionId) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference a sibling under payload.parentId",
+            "payload.positionTargetId must reference a line in the target section",
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const location = findSectionLocation({
+      const lineLocation = findLineLocation({
         state,
-        sectionId: payload.sectionId,
+        lineId: payload.lineId,
       });
-      const targetSceneId = payload.sceneId ?? location.sceneId;
-      const targetScene = state.scenes.items[targetSceneId];
-      targetScene.sections ??= createEmptyNestedCollection();
-      const targetSections = targetScene.sections;
-      const sectionNodeResult = removeNodeOrResult({
-        tree: location.sections.tree,
-        nodeId: payload.sectionId,
-        errorMessage: "section move target missing from tree",
+      lineLocation.section.lines ??= createEmptyNestedCollection();
+      const lineNodeResult = removeNodeOrResult({
+        tree: lineLocation.section.lines.tree,
+        nodeId: payload.lineId,
+        errorMessage: "line move target missing from tree",
       });
-      if (!sectionNodeResult.valid) {
-        return sectionNodeResult;
-      }
-
-      if (targetSections !== location.sections) {
-        const movedSectionIds = collectTreeDescendantIds({
-          node: sectionNodeResult.node,
-        });
-
-        for (const movedSectionId of movedSectionIds) {
-          targetSections.items[movedSectionId] =
-            location.sections.items[movedSectionId];
-          delete location.sections.items[movedSectionId];
-        }
+      if (!lineNodeResult.valid) {
+        return lineNodeResult;
       }
+      const lineValue = lineLocation.line;
+
+      delete lineLocation.section.lines.items[payload.lineId];
+
+      const targetSectionLocation = findSectionLocation({
+        state,
+        sectionId: payload.toSectionId,
+      });
+      targetSectionLocation.section.lines ??= createEmptyNestedCollection();
+      targetSectionLocation.section.lines.items[payload.lineId] = lineValue;
 
       insertTreeNode({
-        tree: targetSections.tree,
-        node: sectionNodeResult.node,
-        parentId: payload.parentId ?? null,
+        tree: targetSectionLocation.section.lines.tree,
+        node: lineNodeResult.node,
         index: payload.index,
         position: payload.position,
         positionTargetId: payload.positionTargetId,
@@ -13674,14 +14859,15 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "line.create",
+    type: "image.create",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "sectionId",
-            "lines",
+            "imageId",
+            "parentId",
+            "data",
             "index",
             "position",
             "positionTargetId",
@@ -13694,13 +14880,23 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.sectionId)) {
-        return invalidPayload("payload.sectionId must be a non-empty string");
+      if (!isNonEmptyString(payload.imageId)) {
+        return invalidPayload("payload.imageId 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 = validateLineCreatePayload({
-          payload,
+        const result = validateImageCreateData({
+          data: payload.data,
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13719,82 +14915,122 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const sectionLocation = findSectionLocation({
-        state,
-        sectionId: payload.sectionId,
-      });
-      if (!sectionLocation) {
-        return invalidPrecondition(
-          "payload.sectionId must reference an existing section",
-        );
+      if (isPlainObject(state.images.items[payload.imageId])) {
+        return invalidPrecondition("payload.imageId must not already exist");
       }
 
-      for (const item of payload.lines) {
-        if (findLineLocation({ state, lineId: item.lineId })) {
+      const parentId = payload.parentId ?? null;
+      if (parentId !== null) {
+        const parentImage = state.images.items[parentId];
+        if (!isPlainObject(parentImage)) {
           return invalidPrecondition(
-            "payload.lines.lineId must not already exist",
-            { lineId: item.lineId },
+            "payload.parentId must reference an existing image item",
+          );
+        }
+
+        if (parentImage.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder image item",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        const targetLocation = findLineLocation({
-          state,
-          lineId: payload.positionTargetId,
-        });
-        if (!targetLocation) {
+        if (!isPlainObject(state.images.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing line",
+            "payload.positionTargetId must reference an existing image item",
           );
         }
 
-        if (targetLocation.sectionId !== payload.sectionId) {
+        const targetParentId = getNodeParentId({
+          tree: state.images.tree,
+          nodeId: payload.positionTargetId,
+        });
+
+        if (targetParentId !== parentId) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference a line in the target section",
+            "payload.positionTargetId must reference a sibling under payload.parentId",
           );
         }
       }
+
+      if (payload.data.type === "image") {
+        const result = validateReferencedFilesInData({
+          state,
+          data: payload.data,
+          fields: ["fileId", "thumbnailFileId"],
+          details: {
+            imageId: payload.imageId,
+          },
+        });
+        if (!result.valid) {
+          return result;
+        }
+
+        return validateTagIdsAgainstScope({
+          state,
+          tagIds: payload.data.tagIds,
+          scopeKey: "images",
+          path: "payload.data.tagIds",
+          details: {
+            imageId: payload.imageId,
+          },
+        });
+      }
     },
     reduce: ({ state, payload }) => {
-      const sectionLocation = findSectionLocation({
-        state,
-        sectionId: payload.sectionId,
-      });
-      sectionLocation.section.lines ??= createEmptyNestedCollection();
-      const lines = sectionLocation.section.lines;
-      let previousLineId = payload.positionTargetId;
+      const nextImage = {
+        id: payload.imageId,
+        type: payload.data.type,
+        name: payload.data.name,
+      };
 
-      payload.lines.forEach((item, index) => {
-        lines.items[item.lineId] = {
-          id: item.lineId,
-          actions: structuredClone(item.data.actions || {}),
-        };
+      if (payload.data.description !== undefined) {
+        nextImage.description = payload.data.description;
+      }
 
-        insertTreeNode({
-          tree: lines.tree,
-          node: { id: item.lineId },
-          index: Number.isInteger(payload.index)
-            ? payload.index + index
-            : undefined,
-          position: index === 0 ? payload.position : "after",
-          positionTargetId:
-            index === 0 ? payload.positionTargetId : previousLineId,
+      if (payload.data.type === "image") {
+        nextImage.fileId = payload.data.fileId;
+        if (payload.data.thumbnailFileId !== undefined) {
+          nextImage.thumbnailFileId = payload.data.thumbnailFileId;
+        }
+        if (payload.data.width !== undefined) {
+          nextImage.width = payload.data.width;
+        }
+        if (payload.data.height !== undefined) {
+          nextImage.height = payload.data.height;
+        }
+
+        assignOptionalTagIds({
+          target: nextImage,
+          tagIds: payload.data.tagIds,
         });
+      }
 
-        previousLineId = item.lineId;
+      state.images.items[payload.imageId] = nextImage;
+
+      insertTreeNode({
+        tree: state.images.tree,
+        node: {
+          id: payload.imageId,
+          children: [],
+        },
+        parentId: payload.parentId ?? null,
+        index: payload.index,
+        position: payload.position,
+        positionTargetId: payload.positionTargetId,
       });
 
       return state;
     },
   },
   {
-    type: "line.update_actions",
+    type: "image.update",
     validatePayload: ({ payload }) => {
       {
-        const result = validateAllowedKeys({
+        const result = validateExactKeys({
           value: payload,
-          allowedKeys: ["lineId", "data", "replace", "preserve"],
+          expectedKeys: ["imageId", "data"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -13803,12 +15039,12 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.lineId)) {
-        return invalidPayload("payload.lineId must be a non-empty string");
+      if (!isNonEmptyString(payload.imageId)) {
+        return invalidPayload("payload.imageId must be a non-empty string");
       }
 
       {
-        const result = validateLineUpdateActionsData({
+        const result = validateImageUpdateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -13816,60 +15052,68 @@ const COMMAND_DEFINITIONS = [
           return result;
         }
       }
+    },
+    validateAgainstState: ({ state, payload }) => {
+      const currentImage = state.images.items[payload.imageId];
+      if (!isPlainObject(currentImage)) {
+        return invalidPrecondition(
+          "payload.imageId must reference an existing image item",
+        );
+      }
 
       if (
-        payload.replace !== undefined &&
-        typeof payload.replace !== "boolean"
+        currentImage.type === "folder" &&
+        (payload.data.fileId !== undefined ||
+          payload.data.thumbnailFileId !== undefined ||
+          payload.data.width !== undefined ||
+          payload.data.height !== undefined ||
+          payload.data.tagIds !== undefined)
       ) {
-        return invalidPayload(
-          "payload.replace must be a boolean when provided",
+        return invalidPrecondition(
+          "folder image items cannot update file fields",
         );
       }
 
-      {
-        const result = validateLineUpdateActionsPreserve({
-          preserve: payload.preserve,
+      if (currentImage.type === "image") {
+        const result = validateReferencedFilesInData({
+          state,
           data: payload.data,
-          replace: payload.replace,
-          errorFactory: createPayloadValidationError,
+          fields: ["fileId", "thumbnailFileId"],
+          details: {
+            imageId: payload.imageId,
+          },
         });
-        if (result?.valid === false) {
+        if (!result.valid) {
           return result;
         }
-      }
-    },
-    validateAgainstState: ({ state, payload }) => {
-      if (!findLineLocation({ state, lineId: payload.lineId })) {
-        return invalidPrecondition(
-          "payload.lineId must reference an existing line",
-        );
+
+        return validateTagIdsAgainstScope({
+          state,
+          tagIds: payload.data.tagIds,
+          scopeKey: "images",
+          path: "payload.data.tagIds",
+          details: {
+            imageId: payload.imageId,
+          },
+        });
       }
     },
     reduce: ({ state, payload }) => {
-      const location = findLineLocation({ state, lineId: payload.lineId });
-      const line = location.line;
-      const nextData = applyLineUpdateActionsPreserve({
-        currentActions: line.actions,
+      const currentImage = state.images.items[payload.imageId];
+      state.images.items[payload.imageId] = applyTagIdsUpdate({
+        currentItem: currentImage,
         data: payload.data,
-        preserve: payload.preserve,
       });
-      line.actions =
-        payload.replace === true
-          ? structuredClone(nextData)
-          : {
-              ...structuredClone(line.actions),
-              ...structuredClone(nextData),
-            };
       return state;
     },
   },
   {
-    type: "line.delete",
+    type: "image.delete",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["lineIds"],
+          expectedKeys: ["imageIds"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -13880,8 +15124,8 @@ const COMMAND_DEFINITIONS = [
 
       {
         const result = validateRequiredUniqueIdArray({
-          value: payload.lineIds,
-          path: "payload.lineIds",
+          value: payload.imageIds,
+          path: "payload.imageIds",
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -13890,38 +15134,49 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      for (const lineId of payload.lineIds) {
-        if (!findLineLocation({ state, lineId })) {
+      for (const imageId of payload.imageIds) {
+        if (!isPlainObject(state.images.items[imageId])) {
           return invalidPrecondition(
-            "payload.lineIds must reference existing lines",
-            { lineId },
+            "payload.imageIds must reference existing image items",
+            { imageId },
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      for (const lineId of payload.lineIds) {
-        const location = findLineLocation({ state, lineId });
-        location.section.lines ??= createEmptyNestedCollection();
-        delete location.section.lines.items[lineId];
-        removeTreeNode({
-          nodes: location.section.lines.tree,
-          nodeId: lineId,
+      const deletedImageIds = new Set();
+
+      for (const imageId of payload.imageIds) {
+        const removedNode = removeTreeNode({
+          nodes: state.images.tree,
+          nodeId: imageId,
         });
+
+        if (!removedNode) {
+          continue;
+        }
+
+        for (const id of collectTreeDescendantIds({ node: removedNode })) {
+          deletedImageIds.add(id);
+        }
+      }
+
+      for (const imageId of deletedImageIds) {
+        delete state.images.items[imageId];
       }
 
       return state;
     },
   },
   {
-    type: "line.move",
+    type: "image.move",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "lineId",
-            "toSectionId",
+            "imageId",
+            "parentId",
             "index",
             "position",
             "positionTargetId",
@@ -13934,12 +15189,18 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.lineId)) {
-        return invalidPayload("payload.lineId must be a non-empty string");
+      if (!isNonEmptyString(payload.imageId)) {
+        return invalidPayload("payload.imageId must be a non-empty string");
       }
 
-      if (!isNonEmptyString(payload.toSectionId)) {
-        return invalidPayload("payload.toSectionId 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",
+        );
       }
 
       {
@@ -13953,78 +15214,84 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const lineLocation = findLineLocation({
-        state,
-        lineId: payload.lineId,
-      });
-      if (!lineLocation) {
+      const image = state.images.items[payload.imageId];
+      if (!isPlainObject(image)) {
         return invalidPrecondition(
-          "payload.lineId must reference an existing line",
+          "payload.imageId must reference an existing image item",
         );
       }
 
-      const targetSectionLocation = findSectionLocation({
-        state,
-        sectionId: payload.toSectionId,
+      const imageNode = findTreeNode({
+        nodes: state.images.tree,
+        nodeId: payload.imageId,
       });
-      if (!targetSectionLocation) {
-        return invalidPrecondition(
-          "payload.toSectionId must reference an existing section",
+
+      if (payload.parentId !== undefined && payload.parentId !== null) {
+        const parentImage = state.images.items[payload.parentId];
+        if (!isPlainObject(parentImage)) {
+          return invalidPrecondition(
+            "payload.parentId must reference an existing image item",
+          );
+        }
+
+        if (parentImage.type !== "folder") {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder image item",
+          );
+        }
+
+        const descendantIds = new Set(
+          collectTreeDescendantIds({
+            node: imageNode,
+          }),
         );
+
+        if (descendantIds.has(payload.parentId)) {
+          return invalidPrecondition(
+            "payload.parentId must not target the moved image item or its descendants",
+          );
+        }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (payload.positionTargetId === payload.lineId) {
+        if (payload.positionTargetId === payload.imageId) {
           return invalidPrecondition(
-            "payload.positionTargetId must not reference the moved line",
+            "payload.positionTargetId must not reference the moved image item",
           );
         }
 
-        const targetLocation = findLineLocation({
-          state,
-          lineId: payload.positionTargetId,
-        });
-        if (!targetLocation) {
+        if (!isPlainObject(state.images.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing line",
+            "payload.positionTargetId must reference an existing image item",
           );
         }
 
-        if (targetLocation.sectionId !== payload.toSectionId) {
+        const targetParentId = getNodeParentId({
+          tree: state.images.tree,
+          nodeId: payload.positionTargetId,
+        });
+
+        if (targetParentId !== (payload.parentId ?? null)) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference a line in the target section",
+            "payload.positionTargetId must reference a sibling under payload.parentId",
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const lineLocation = findLineLocation({
-        state,
-        lineId: payload.lineId,
-      });
-      lineLocation.section.lines ??= createEmptyNestedCollection();
-      const lineNodeResult = removeNodeOrResult({
-        tree: lineLocation.section.lines.tree,
-        nodeId: payload.lineId,
-        errorMessage: "line move target missing from tree",
+      const imageNodeResult = removeNodeOrResult({
+        tree: state.images.tree,
+        nodeId: payload.imageId,
+        errorMessage: "image move target missing from tree",
       });
-      if (!lineNodeResult.valid) {
-        return lineNodeResult;
+      if (!imageNodeResult.valid) {
+        return imageNodeResult;
       }
-      const lineValue = lineLocation.line;
-
-      delete lineLocation.section.lines.items[payload.lineId];
-
-      const targetSectionLocation = findSectionLocation({
-        state,
-        sectionId: payload.toSectionId,
-      });
-      targetSectionLocation.section.lines ??= createEmptyNestedCollection();
-      targetSectionLocation.section.lines.items[payload.lineId] = lineValue;
 
       insertTreeNode({
-        tree: targetSectionLocation.section.lines.tree,
-        node: lineNodeResult.node,
+        tree: state.images.tree,
+        node: imageNodeResult.node,
+        parentId: payload.parentId ?? null,
         index: payload.index,
         position: payload.position,
         positionTargetId: payload.positionTargetId,
@@ -14034,13 +15301,13 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "image.create",
+    type: "sound.create",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "imageId",
+            "soundId",
             "parentId",
             "data",
             "index",
@@ -14055,8 +15322,8 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.imageId)) {
-        return invalidPayload("payload.imageId must be a non-empty string");
+      if (!isNonEmptyString(payload.soundId)) {
+        return invalidPayload("payload.soundId must be a non-empty string");
       }
 
       if (
@@ -14070,7 +15337,7 @@ const COMMAND_DEFINITIONS = [
       }
 
       {
-        const result = validateImageCreateData({
+        const result = validateSoundCreateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -14090,35 +15357,35 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      if (isPlainObject(state.images.items[payload.imageId])) {
-        return invalidPrecondition("payload.imageId must not already exist");
+      if (isPlainObject(state.sounds.items[payload.soundId])) {
+        return invalidPrecondition("payload.soundId must not already exist");
       }
 
       const parentId = payload.parentId ?? null;
       if (parentId !== null) {
-        const parentImage = state.images.items[parentId];
-        if (!isPlainObject(parentImage)) {
+        const parentSound = state.sounds.items[parentId];
+        if (!isPlainObject(parentSound)) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing image item",
+            "payload.parentId must reference an existing sound item",
           );
         }
 
-        if (parentImage.type !== "folder") {
+        if (parentSound.type !== "folder") {
           return invalidPrecondition(
-            "payload.parentId must reference a folder image item",
+            "payload.parentId must reference a folder sound item",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (!isPlainObject(state.images.items[payload.positionTargetId])) {
+        if (!isPlainObject(state.sounds.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing image item",
+            "payload.positionTargetId must reference an existing sound item",
           );
         }
 
         const targetParentId = getNodeParentId({
-          tree: state.images.tree,
+          tree: state.sounds.tree,
           nodeId: payload.positionTargetId,
         });
 
@@ -14129,13 +15396,14 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (payload.data.type === "image") {
+      if (payload.data.type === "sound") {
         const result = validateReferencedFilesInData({
           state,
           data: payload.data,
-          fields: ["fileId", "thumbnailFileId"],
+          fields: ["fileId", "waveformDataFileId"],
+          nullableFields: ["waveformDataFileId"],
           details: {
-            imageId: payload.imageId,
+            soundId: payload.soundId,
           },
         });
         if (!result.valid) {
@@ -14145,49 +15413,46 @@ const COMMAND_DEFINITIONS = [
         return validateTagIdsAgainstScope({
           state,
           tagIds: payload.data.tagIds,
-          scopeKey: "images",
+          scopeKey: "sounds",
           path: "payload.data.tagIds",
           details: {
-            imageId: payload.imageId,
+            soundId: payload.soundId,
           },
         });
       }
     },
     reduce: ({ state, payload }) => {
-      const nextImage = {
-        id: payload.imageId,
+      const nextSound = {
+        id: payload.soundId,
         type: payload.data.type,
         name: payload.data.name,
       };
 
       if (payload.data.description !== undefined) {
-        nextImage.description = payload.data.description;
+        nextSound.description = payload.data.description;
       }
 
-      if (payload.data.type === "image") {
-        nextImage.fileId = payload.data.fileId;
-        if (payload.data.thumbnailFileId !== undefined) {
-          nextImage.thumbnailFileId = payload.data.thumbnailFileId;
-        }
-        if (payload.data.width !== undefined) {
-          nextImage.width = payload.data.width;
+      if (payload.data.type === "sound") {
+        nextSound.fileId = payload.data.fileId;
+        if (payload.data.waveformDataFileId !== undefined) {
+          nextSound.waveformDataFileId = payload.data.waveformDataFileId;
         }
-        if (payload.data.height !== undefined) {
-          nextImage.height = payload.data.height;
+        if (payload.data.duration !== undefined) {
+          nextSound.duration = payload.data.duration;
         }
 
         assignOptionalTagIds({
-          target: nextImage,
+          target: nextSound,
           tagIds: payload.data.tagIds,
         });
       }
 
-      state.images.items[payload.imageId] = nextImage;
+      state.sounds.items[payload.soundId] = nextSound;
 
       insertTreeNode({
-        tree: state.images.tree,
+        tree: state.sounds.tree,
         node: {
-          id: payload.imageId,
+          id: payload.soundId,
           children: [],
         },
         parentId: payload.parentId ?? null,
@@ -14200,12 +15465,12 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "image.update",
+    type: "sound.update",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["imageId", "data"],
+          expectedKeys: ["soundId", "data"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -14214,12 +15479,12 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.imageId)) {
-        return invalidPayload("payload.imageId must be a non-empty string");
+      if (!isNonEmptyString(payload.soundId)) {
+        return invalidPayload("payload.soundId must be a non-empty string");
       }
 
       {
-        const result = validateImageUpdateData({
+        const result = validateSoundUpdateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -14229,33 +15494,33 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const currentImage = state.images.items[payload.imageId];
-      if (!isPlainObject(currentImage)) {
+      const currentSound = state.sounds.items[payload.soundId];
+      if (!isPlainObject(currentSound)) {
         return invalidPrecondition(
-          "payload.imageId must reference an existing image item",
+          "payload.soundId must reference an existing sound item",
         );
       }
 
       if (
-        currentImage.type === "folder" &&
+        currentSound.type === "folder" &&
         (payload.data.fileId !== undefined ||
-          payload.data.thumbnailFileId !== undefined ||
-          payload.data.width !== undefined ||
-          payload.data.height !== undefined ||
+          payload.data.waveformDataFileId !== undefined ||
+          payload.data.duration !== undefined ||
           payload.data.tagIds !== undefined)
       ) {
         return invalidPrecondition(
-          "folder image items cannot update file fields",
+          "folder sound items cannot update file fields",
         );
       }
 
-      if (currentImage.type === "image") {
+      if (currentSound.type === "sound") {
         const result = validateReferencedFilesInData({
           state,
           data: payload.data,
-          fields: ["fileId", "thumbnailFileId"],
+          fields: ["fileId", "waveformDataFileId"],
+          nullableFields: ["waveformDataFileId"],
           details: {
-            imageId: payload.imageId,
+            soundId: payload.soundId,
           },
         });
         if (!result.valid) {
@@ -14265,30 +15530,30 @@ const COMMAND_DEFINITIONS = [
         return validateTagIdsAgainstScope({
           state,
           tagIds: payload.data.tagIds,
-          scopeKey: "images",
+          scopeKey: "sounds",
           path: "payload.data.tagIds",
           details: {
-            imageId: payload.imageId,
+            soundId: payload.soundId,
           },
         });
       }
     },
     reduce: ({ state, payload }) => {
-      const currentImage = state.images.items[payload.imageId];
-      state.images.items[payload.imageId] = applyTagIdsUpdate({
-        currentItem: currentImage,
+      const currentSound = state.sounds.items[payload.soundId];
+      state.sounds.items[payload.soundId] = applyTagIdsUpdate({
+        currentItem: currentSound,
         data: payload.data,
       });
       return state;
     },
   },
   {
-    type: "image.delete",
+    type: "sound.delete",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["imageIds"],
+          expectedKeys: ["soundIds"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -14299,8 +15564,8 @@ const COMMAND_DEFINITIONS = [
 
       {
         const result = validateRequiredUniqueIdArray({
-          value: payload.imageIds,
-          path: "payload.imageIds",
+          value: payload.soundIds,
+          path: "payload.soundIds",
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -14309,22 +15574,22 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      for (const imageId of payload.imageIds) {
-        if (!isPlainObject(state.images.items[imageId])) {
+      for (const soundId of payload.soundIds) {
+        if (!isPlainObject(state.sounds.items[soundId])) {
           return invalidPrecondition(
-            "payload.imageIds must reference existing image items",
-            { imageId },
+            "payload.soundIds must reference existing sound items",
+            { soundId },
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const deletedImageIds = new Set();
+      const deletedSoundIds = new Set();
 
-      for (const imageId of payload.imageIds) {
+      for (const soundId of payload.soundIds) {
         const removedNode = removeTreeNode({
-          nodes: state.images.tree,
-          nodeId: imageId,
+          nodes: state.sounds.tree,
+          nodeId: soundId,
         });
 
         if (!removedNode) {
@@ -14332,25 +15597,25 @@ const COMMAND_DEFINITIONS = [
         }
 
         for (const id of collectTreeDescendantIds({ node: removedNode })) {
-          deletedImageIds.add(id);
+          deletedSoundIds.add(id);
         }
       }
 
-      for (const imageId of deletedImageIds) {
-        delete state.images.items[imageId];
+      for (const soundId of deletedSoundIds) {
+        delete state.sounds.items[soundId];
       }
 
       return state;
     },
   },
   {
-    type: "image.move",
+    type: "sound.move",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "imageId",
+            "soundId",
             "parentId",
             "index",
             "position",
@@ -14364,8 +15629,8 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.imageId)) {
-        return invalidPayload("payload.imageId must be a non-empty string");
+      if (!isNonEmptyString(payload.soundId)) {
+        return invalidPayload("payload.soundId must be a non-empty string");
       }
 
       if (
@@ -14389,60 +15654,60 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const image = state.images.items[payload.imageId];
-      if (!isPlainObject(image)) {
+      const sound = state.sounds.items[payload.soundId];
+      if (!isPlainObject(sound)) {
         return invalidPrecondition(
-          "payload.imageId must reference an existing image item",
+          "payload.soundId must reference an existing sound item",
         );
       }
 
-      const imageNode = findTreeNode({
-        nodes: state.images.tree,
-        nodeId: payload.imageId,
+      const soundNode = findTreeNode({
+        nodes: state.sounds.tree,
+        nodeId: payload.soundId,
       });
 
       if (payload.parentId !== undefined && payload.parentId !== null) {
-        const parentImage = state.images.items[payload.parentId];
-        if (!isPlainObject(parentImage)) {
+        const parentSound = state.sounds.items[payload.parentId];
+        if (!isPlainObject(parentSound)) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing image item",
+            "payload.parentId must reference an existing sound item",
           );
         }
 
-        if (parentImage.type !== "folder") {
+        if (parentSound.type !== "folder") {
           return invalidPrecondition(
-            "payload.parentId must reference a folder image item",
+            "payload.parentId must reference a folder sound item",
           );
         }
 
         const descendantIds = new Set(
           collectTreeDescendantIds({
-            node: imageNode,
+            node: soundNode,
           }),
         );
 
         if (descendantIds.has(payload.parentId)) {
           return invalidPrecondition(
-            "payload.parentId must not target the moved image item or its descendants",
+            "payload.parentId must not target the moved sound item or its descendants",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (payload.positionTargetId === payload.imageId) {
+        if (payload.positionTargetId === payload.soundId) {
           return invalidPrecondition(
-            "payload.positionTargetId must not reference the moved image item",
+            "payload.positionTargetId must not reference the moved sound item",
           );
         }
 
-        if (!isPlainObject(state.images.items[payload.positionTargetId])) {
+        if (!isPlainObject(state.sounds.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing image item",
+            "payload.positionTargetId must reference an existing sound item",
           );
         }
 
         const targetParentId = getNodeParentId({
-          tree: state.images.tree,
+          tree: state.sounds.tree,
           nodeId: payload.positionTargetId,
         });
 
@@ -14454,18 +15719,18 @@ const COMMAND_DEFINITIONS = [
       }
     },
     reduce: ({ state, payload }) => {
-      const imageNodeResult = removeNodeOrResult({
-        tree: state.images.tree,
-        nodeId: payload.imageId,
-        errorMessage: "image move target missing from tree",
+      const soundNodeResult = removeNodeOrResult({
+        tree: state.sounds.tree,
+        nodeId: payload.soundId,
+        errorMessage: "sound move target missing from tree",
       });
-      if (!imageNodeResult.valid) {
-        return imageNodeResult;
+      if (!soundNodeResult.valid) {
+        return soundNodeResult;
       }
 
       insertTreeNode({
-        tree: state.images.tree,
-        node: imageNodeResult.node,
+        tree: state.sounds.tree,
+        node: soundNodeResult.node,
         parentId: payload.parentId ?? null,
         index: payload.index,
         position: payload.position,
@@ -14476,13 +15741,13 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "sound.create",
+    type: "voice.create",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "soundId",
+            "voiceId",
             "parentId",
             "data",
             "index",
@@ -14497,8 +15762,8 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.soundId)) {
-        return invalidPayload("payload.soundId must be a non-empty string");
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
       }
 
       if (
@@ -14512,7 +15777,7 @@ const COMMAND_DEFINITIONS = [
       }
 
       {
-        const result = validateSoundCreateData({
+        const result = validateVoiceCreateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -14532,35 +15797,35 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      if (isPlainObject(state.sounds.items[payload.soundId])) {
-        return invalidPrecondition("payload.soundId must not already exist");
+      if (isPlainObject(state.voices.items[payload.voiceId])) {
+        return invalidPrecondition("payload.voiceId must not already exist");
       }
 
       const parentId = payload.parentId ?? null;
       if (parentId !== null) {
-        const parentSound = state.sounds.items[parentId];
-        if (!isPlainObject(parentSound)) {
+        const parentVoice = state.voices.items[parentId];
+        if (!isPlainObject(parentVoice)) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing sound item",
+            "payload.parentId must reference an existing voice item",
           );
         }
 
-        if (parentSound.type !== "folder") {
+        if (parentVoice.type !== "folder") {
           return invalidPrecondition(
-            "payload.parentId must reference a folder sound item",
+            "payload.parentId must reference a folder voice item",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (!isPlainObject(state.sounds.items[payload.positionTargetId])) {
+        if (!isPlainObject(state.voices.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing sound item",
+            "payload.positionTargetId must reference an existing voice item",
           );
         }
 
         const targetParentId = getNodeParentId({
-          tree: state.sounds.tree,
+          tree: state.voices.tree,
           nodeId: payload.positionTargetId,
         });
 
@@ -14571,63 +15836,53 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (payload.data.type === "sound") {
-        const result = validateReferencedFilesInData({
+      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: {
-            soundId: payload.soundId,
-          },
-        });
-        if (!result.valid) {
-          return result;
-        }
-
-        return validateTagIdsAgainstScope({
-          state,
-          tagIds: payload.data.tagIds,
-          scopeKey: "sounds",
-          path: "payload.data.tagIds",
-          details: {
-            soundId: payload.soundId,
+            voiceId: payload.voiceId,
           },
         });
       }
     },
     reduce: ({ state, payload }) => {
-      const nextSound = {
-        id: payload.soundId,
+      const nextVoice = {
+        id: payload.voiceId,
         type: payload.data.type,
         name: payload.data.name,
       };
 
       if (payload.data.description !== undefined) {
-        nextSound.description = payload.data.description;
+        nextVoice.description = payload.data.description;
       }
 
-      if (payload.data.type === "sound") {
-        nextSound.fileId = payload.data.fileId;
+      if (payload.data.type === "voice") {
+        nextVoice.sceneId = payload.data.sceneId;
+        nextVoice.fileId = payload.data.fileId;
         if (payload.data.waveformDataFileId !== undefined) {
-          nextSound.waveformDataFileId = payload.data.waveformDataFileId;
+          nextVoice.waveformDataFileId = payload.data.waveformDataFileId;
         }
         if (payload.data.duration !== undefined) {
-          nextSound.duration = payload.data.duration;
+          nextVoice.duration = payload.data.duration;
         }
-
-        assignOptionalTagIds({
-          target: nextSound,
-          tagIds: payload.data.tagIds,
-        });
       }
 
-      state.sounds.items[payload.soundId] = nextSound;
+      state.voices.items[payload.voiceId] = nextVoice;
 
       insertTreeNode({
-        tree: state.sounds.tree,
+        tree: state.voices.tree,
         node: {
-          id: payload.soundId,
+          id: payload.voiceId,
           children: [],
         },
         parentId: payload.parentId ?? null,
@@ -14640,12 +15895,12 @@ const COMMAND_DEFINITIONS = [
     },
   },
   {
-    type: "sound.update",
+    type: "voice.update",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["soundId", "data"],
+          expectedKeys: ["voiceId", "data"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -14654,12 +15909,12 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.soundId)) {
-        return invalidPayload("payload.soundId must be a non-empty string");
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
       }
 
       {
-        const result = validateSoundUpdateData({
+        const result = validateVoiceUpdateData({
           data: payload.data,
           errorFactory: createPayloadValidationError,
         });
@@ -14669,66 +15924,61 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const currentSound = state.sounds.items[payload.soundId];
-      if (!isPlainObject(currentSound)) {
+      const currentVoice = state.voices.items[payload.voiceId];
+      if (!isPlainObject(currentVoice)) {
         return invalidPrecondition(
-          "payload.soundId must reference an existing sound item",
+          "payload.voiceId must reference an existing voice item",
         );
       }
 
       if (
-        currentSound.type === "folder" &&
-        (payload.data.fileId !== undefined ||
+        currentVoice.type === "folder" &&
+        (payload.data.sceneId !== undefined ||
+          payload.data.fileId !== undefined ||
           payload.data.waveformDataFileId !== undefined ||
-          payload.data.duration !== undefined ||
-          payload.data.tagIds !== undefined)
+          payload.data.duration !== undefined)
       ) {
         return invalidPrecondition(
-          "folder sound items cannot update file fields",
+          "folder voice items cannot update file fields",
         );
       }
 
-      if (currentSound.type === "sound") {
-        const result = validateReferencedFilesInData({
+      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: {
-            soundId: payload.soundId,
-          },
-        });
-        if (!result.valid) {
-          return result;
-        }
-
-        return validateTagIdsAgainstScope({
-          state,
-          tagIds: payload.data.tagIds,
-          scopeKey: "sounds",
-          path: "payload.data.tagIds",
-          details: {
-            soundId: payload.soundId,
+            voiceId: payload.voiceId,
           },
         });
       }
     },
     reduce: ({ state, payload }) => {
-      const currentSound = state.sounds.items[payload.soundId];
-      state.sounds.items[payload.soundId] = applyTagIdsUpdate({
-        currentItem: currentSound,
-        data: payload.data,
-      });
+      state.voices.items[payload.voiceId] = {
+        ...structuredClone(state.voices.items[payload.voiceId]),
+        ...structuredClone(payload.data),
+      };
       return state;
     },
   },
   {
-    type: "sound.delete",
+    type: "voice.delete",
     validatePayload: ({ payload }) => {
       {
         const result = validateExactKeys({
           value: payload,
-          expectedKeys: ["soundIds"],
+          expectedKeys: ["voiceIds"],
           path: "payload",
           errorFactory: createPayloadValidationError,
         });
@@ -14739,8 +15989,8 @@ const COMMAND_DEFINITIONS = [
 
       {
         const result = validateRequiredUniqueIdArray({
-          value: payload.soundIds,
-          path: "payload.soundIds",
+          value: payload.voiceIds,
+          path: "payload.voiceIds",
           errorFactory: createPayloadValidationError,
         });
         if (result?.valid === false) {
@@ -14749,22 +15999,22 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      for (const soundId of payload.soundIds) {
-        if (!isPlainObject(state.sounds.items[soundId])) {
+      for (const voiceId of payload.voiceIds) {
+        if (!isPlainObject(state.voices.items[voiceId])) {
           return invalidPrecondition(
-            "payload.soundIds must reference existing sound items",
-            { soundId },
+            "payload.voiceIds must reference existing voice items",
+            { voiceId },
           );
         }
       }
     },
     reduce: ({ state, payload }) => {
-      const deletedSoundIds = new Set();
+      const deletedVoiceIds = new Set();
 
-      for (const soundId of payload.soundIds) {
+      for (const voiceId of payload.voiceIds) {
         const removedNode = removeTreeNode({
-          nodes: state.sounds.tree,
-          nodeId: soundId,
+          nodes: state.voices.tree,
+          nodeId: voiceId,
         });
 
         if (!removedNode) {
@@ -14772,25 +16022,25 @@ const COMMAND_DEFINITIONS = [
         }
 
         for (const id of collectTreeDescendantIds({ node: removedNode })) {
-          deletedSoundIds.add(id);
+          deletedVoiceIds.add(id);
         }
       }
 
-      for (const soundId of deletedSoundIds) {
-        delete state.sounds.items[soundId];
+      for (const voiceId of deletedVoiceIds) {
+        delete state.voices.items[voiceId];
       }
 
       return state;
     },
   },
   {
-    type: "sound.move",
+    type: "voice.move",
     validatePayload: ({ payload }) => {
       {
         const result = validateAllowedKeys({
           value: payload,
           allowedKeys: [
-            "soundId",
+            "voiceId",
             "parentId",
             "index",
             "position",
@@ -14804,8 +16054,8 @@ const COMMAND_DEFINITIONS = [
         }
       }
 
-      if (!isNonEmptyString(payload.soundId)) {
-        return invalidPayload("payload.soundId must be a non-empty string");
+      if (!isNonEmptyString(payload.voiceId)) {
+        return invalidPayload("payload.voiceId must be a non-empty string");
       }
 
       if (
@@ -14829,60 +16079,60 @@ const COMMAND_DEFINITIONS = [
       }
     },
     validateAgainstState: ({ state, payload }) => {
-      const sound = state.sounds.items[payload.soundId];
-      if (!isPlainObject(sound)) {
+      const voice = state.voices.items[payload.voiceId];
+      if (!isPlainObject(voice)) {
         return invalidPrecondition(
-          "payload.soundId must reference an existing sound item",
+          "payload.voiceId must reference an existing voice item",
         );
       }
 
-      const soundNode = findTreeNode({
-        nodes: state.sounds.tree,
-        nodeId: payload.soundId,
+      const voiceNode = findTreeNode({
+        nodes: state.voices.tree,
+        nodeId: payload.voiceId,
       });
 
       if (payload.parentId !== undefined && payload.parentId !== null) {
-        const parentSound = state.sounds.items[payload.parentId];
-        if (!isPlainObject(parentSound)) {
+        const parentVoice = state.voices.items[payload.parentId];
+        if (!isPlainObject(parentVoice)) {
           return invalidPrecondition(
-            "payload.parentId must reference an existing sound item",
+            "payload.parentId must reference an existing voice item",
           );
         }
 
-        if (parentSound.type !== "folder") {
+        if (parentVoice.type !== "folder") {
           return invalidPrecondition(
-            "payload.parentId must reference a folder sound item",
+            "payload.parentId must reference a folder voice item",
           );
         }
 
         const descendantIds = new Set(
           collectTreeDescendantIds({
-            node: soundNode,
+            node: voiceNode,
           }),
         );
 
         if (descendantIds.has(payload.parentId)) {
           return invalidPrecondition(
-            "payload.parentId must not target the moved sound item or its descendants",
+            "payload.parentId must not target the moved voice item or its descendants",
           );
         }
       }
 
       if (payload.positionTargetId !== undefined) {
-        if (payload.positionTargetId === payload.soundId) {
+        if (payload.positionTargetId === payload.voiceId) {
           return invalidPrecondition(
-            "payload.positionTargetId must not reference the moved sound item",
+            "payload.positionTargetId must not reference the moved voice item",
           );
         }
 
-        if (!isPlainObject(state.sounds.items[payload.positionTargetId])) {
+        if (!isPlainObject(state.voices.items[payload.positionTargetId])) {
           return invalidPrecondition(
-            "payload.positionTargetId must reference an existing sound item",
+            "payload.positionTargetId must reference an existing voice item",
           );
         }
 
         const targetParentId = getNodeParentId({
-          tree: state.sounds.tree,
+          tree: state.voices.tree,
           nodeId: payload.positionTargetId,
         });
 
@@ -14894,18 +16144,18 @@ const COMMAND_DEFINITIONS = [
       }
     },
     reduce: ({ state, payload }) => {
-      const soundNodeResult = removeNodeOrResult({
-        tree: state.sounds.tree,
-        nodeId: payload.soundId,
-        errorMessage: "sound move target missing from tree",
+      const voiceNodeResult = removeNodeOrResult({
+        tree: state.voices.tree,
+        nodeId: payload.voiceId,
+        errorMessage: "voice move target missing from tree",
       });
-      if (!soundNodeResult.valid) {
-        return soundNodeResult;
+      if (!voiceNodeResult.valid) {
+        return voiceNodeResult;
       }
 
       insertTreeNode({
-        tree: state.sounds.tree,
-        node: soundNodeResult.node,
+        tree: state.voices.tree,
+        node: voiceNodeResult.node,
         parentId: payload.parentId ?? null,
         index: payload.index,
         position: payload.position,
@@ -17736,6 +18986,16 @@ const COMMAND_DEFINITIONS = [
             "payload.parentId must reference a folder sprite item",
           );
         }
+
+        const parentNode = findTreeNode({
+          nodes: collection.tree,
+          nodeId: parentId,
+        });
+        if (!parentNode) {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder sprite item in the tree",
+          );
+        }
       }
 
       if (payload.positionTargetId !== undefined) {
@@ -17745,6 +19005,16 @@ const COMMAND_DEFINITIONS = [
           );
         }
 
+        const targetNode = findTreeNode({
+          nodes: collection.tree,
+          nodeId: payload.positionTargetId,
+        });
+        if (!targetNode) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing sprite item in the tree",
+          );
+        }
+
         const targetParentId = getNodeParentId({
           tree: collection.tree,
           nodeId: payload.positionTargetId,
@@ -18076,6 +19346,11 @@ const COMMAND_DEFINITIONS = [
         nodes: collection.tree,
         nodeId: payload.spriteId,
       });
+      if (!currentNode) {
+        return invalidPrecondition(
+          "payload.spriteId must reference an existing sprite item in the tree",
+        );
+      }
 
       if (payload.parentId !== undefined && payload.parentId !== null) {
         const parentItem = collection.items[payload.parentId];
@@ -18085,6 +19360,16 @@ const COMMAND_DEFINITIONS = [
           );
         }
 
+        const parentNode = findTreeNode({
+          nodes: collection.tree,
+          nodeId: payload.parentId,
+        });
+        if (!parentNode) {
+          return invalidPrecondition(
+            "payload.parentId must reference a folder sprite item in the tree",
+          );
+        }
+
         const descendantIds = new Set(
           collectTreeDescendantIds({
             node: currentNode,
@@ -18111,6 +19396,16 @@ const COMMAND_DEFINITIONS = [
           );
         }
 
+        const targetNode = findTreeNode({
+          nodes: collection.tree,
+          nodeId: payload.positionTargetId,
+        });
+        if (!targetNode) {
+          return invalidPrecondition(
+            "payload.positionTargetId must reference an existing sprite item in the tree",
+          );
+        }
+
         const targetParentId = getNodeParentId({
           tree: collection.tree,
           nodeId: payload.positionTargetId,