webeditor3d/tests/domain/transform-session.command.test.ts

import { describe, expect, it } from "vitest";

import { createEditorStore } from "../../src/app/editor-store";
import { createModelInstance } from "../../src/assets/model-instances";
import {
  createProjectAssetStorageKey,
  type ModelAssetRecord
} from "../../src/assets/project-assets";
import { createCommitTransformSessionCommand } from "../../src/commands/commit-transform-session-command";
import {
  createTransformSession,
  resolveTransformTarget,
  supportsLocalTransformAxisConstraint,
  supportsTransformAxisConstraint,
  supportsTransformOperation
} from "../../src/core/transform-session";
import {
  cloneBoxBrushGeometry,
  createBoxBrush
} from "../../src/document/brushes";
import { createScenePath } from "../../src/document/paths";
import { createEmptySceneDocument } from "../../src/document/scene-document";
import {
  createPlayerStartEntity,
  createTriggerVolumeEntity
} from "../../src/entities/entity-instances";
import { getBoxBrushLocalVertexPosition } from "../../src/geometry/box-brush-mesh";

const modelAsset = {
  id: "asset-model-transform-fixture",
  kind: "model",
  sourceName: "transform-fixture.glb",
  mimeType: "model/gltf-binary",
  storageKey: createProjectAssetStorageKey("asset-model-transform-fixture"),
  byteLength: 64,
  metadata: {
    kind: "model",
    format: "glb",
    sceneName: "Transform Fixture",
    nodeCount: 1,
    meshCount: 1,
    materialNames: [],
    textureNames: [],
    animationNames: [],
    boundingBox: {
      min: {
        x: -0.5,
        y: 0,
        z: -0.5
      },
      max: {
        x: 0.5,
        y: 1,
        z: 0.5
      },
      size: {
        x: 1,
        y: 1,
        z: 1
      }
    },
    warnings: []
  }
} satisfies ModelAssetRecord;

describe("transform session commit commands", () => {
  it("resolves component transform targets in matching mode and enforces operation support", () => {
    const brush = createBoxBrush({
      id: "brush-main"
    });
    const path = createScenePath({
      id: "path-main",
      points: [
        {
          id: "path-point-a",
          position: {
            x: -1,
            y: 0,
            z: 0
          }
        },
        {
          id: "path-point-b",
          position: {
            x: 2,
            y: 1,
            z: 0
          }
        }
      ]
    });
    const document = {
      ...createEmptySceneDocument(),
      brushes: {
        [brush.id]: brush
      },
      paths: {
        [path.id]: path
      }
    };

    const faceWrongModeResolved = resolveTransformTarget(document, {
      kind: "brushFace",
      brushId: brush.id,
      faceId: "posZ"
    });
    const faceResolved = resolveTransformTarget(
      document,
      {
        kind: "brushFace",
        brushId: brush.id,
        faceId: "posZ"
      },
      "face"
    );
    const edgeResolved = resolveTransformTarget(
      document,
      {
        kind: "brushEdge",
        brushId: brush.id,
        edgeId: "edgeX_posY_negZ"
      },
      "edge"
    );
    const vertexResolved = resolveTransformTarget(
      document,
      {
        kind: "brushVertex",
        brushId: brush.id,
        vertexId: "posX_posY_negZ"
      },
      "vertex"
    );
    const faceModeBrushResolved = resolveTransformTarget(
      document,
      {
        kind: "brushes",
        ids: [brush.id]
      },
      "face"
    );
    const objectResolved = resolveTransformTarget(document, {
      kind: "brushes",
      ids: [brush.id]
    });
    const pathObjectResolved = resolveTransformTarget(document, {
      kind: "paths",
      ids: [path.id]
    });
    const pathPointResolved = resolveTransformTarget(document, {
      kind: "pathPoint",
      pathId: path.id,
      pointId: path.points[1].id
    });

    expect(faceWrongModeResolved.target).toBeNull();
    expect(faceWrongModeResolved.message).toContain("Face mode");
    expect(faceResolved.target).toMatchObject({
      kind: "brushFace",
      brushId: brush.id,
      faceId: "posZ"
    });
    expect(edgeResolved.target).toMatchObject({
      kind: "brushEdge",
      brushId: brush.id,
      edgeId: "edgeX_posY_negZ"
    });
    expect(vertexResolved.target).toMatchObject({
      kind: "brushVertex",
      brushId: brush.id,
      vertexId: "posX_posY_negZ"
    });
    expect(faceModeBrushResolved.target).toBeNull();
    expect(faceModeBrushResolved.message).toContain("Object mode");
    expect(objectResolved.target).toMatchObject({
      kind: "brush",
      brushId: brush.id,
      initialCenter: brush.center,
      initialRotationDegrees: brush.rotationDegrees,
      initialSize: brush.size
    });
    expect(pathObjectResolved.target).toBeNull();
    expect(pathObjectResolved.message).toContain("path point");
    expect(pathPointResolved.target).toMatchObject({
      kind: "pathPoint",
      pathId: path.id,
      pointId: path.points[1].id,
      initialPosition: path.points[1].position
    });
    expect(objectResolved.target).not.toBeNull();
    expect(
      supportsTransformOperation(
        objectResolved.target as NonNullable<typeof objectResolved.target>,
        "translate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        objectResolved.target as NonNullable<typeof objectResolved.target>,
        "rotate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        objectResolved.target as NonNullable<typeof objectResolved.target>,
        "scale"
      )
    ).toBe(true);

    expect(
      supportsTransformOperation(
        faceResolved.target as NonNullable<typeof faceResolved.target>,
        "translate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        faceResolved.target as NonNullable<typeof faceResolved.target>,
        "rotate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        faceResolved.target as NonNullable<typeof faceResolved.target>,
        "scale"
      )
    ).toBe(true);

    expect(
      supportsTransformOperation(
        vertexResolved.target as NonNullable<typeof vertexResolved.target>,
        "translate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        vertexResolved.target as NonNullable<typeof vertexResolved.target>,
        "rotate"
      )
    ).toBe(false);
    expect(
      supportsTransformOperation(
        vertexResolved.target as NonNullable<typeof vertexResolved.target>,
        "scale"
      )
    ).toBe(false);

    expect(
      supportsTransformOperation(
        pathPointResolved.target as NonNullable<typeof pathPointResolved.target>,
        "translate"
      )
    ).toBe(true);
    expect(
      supportsTransformOperation(
        pathPointResolved.target as NonNullable<typeof pathPointResolved.target>,
        "rotate"
      )
    ).toBe(false);
    expect(
      supportsTransformOperation(
        pathPointResolved.target as NonNullable<typeof pathPointResolved.target>,
        "scale"
      )
    ).toBe(false);
  });

  it("applies axis-constraint rules across object and component transform sessions", () => {
    const brush = createBoxBrush({
      id: "brush-axis-rules"
    });
    const document = {
      ...createEmptySceneDocument(),
      brushes: {
        [brush.id]: brush
      }
    };

    const faceTarget = resolveTransformTarget(
      document,
      {
        kind: "brushFace",
        brushId: brush.id,
        faceId: "posX"
      },
      "face"
    ).target;
    const edgeTarget = resolveTransformTarget(
      document,
      {
        kind: "brushEdge",
        brushId: brush.id,
        edgeId: "edgeY_posX_posZ"
      },
      "edge"
    ).target;
    const vertexTarget = resolveTransformTarget(
      document,
      {
        kind: "brushVertex",
        brushId: brush.id,
        vertexId: "posX_posY_posZ"
      },
      "vertex"
    ).target;

    if (faceTarget === null || faceTarget.kind !== "brushFace") {
      throw new Error("Expected a face transform target.");
    }

    if (edgeTarget === null || edgeTarget.kind !== "brushEdge") {
      throw new Error("Expected an edge transform target.");
    }

    if (vertexTarget === null || vertexTarget.kind !== "brushVertex") {
      throw new Error("Expected a vertex transform target.");
    }

    const faceRotateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "rotate",
      target: faceTarget
    });
    const edgeScaleSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "scale",
      target: edgeTarget
    });
    const vertexTranslateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target: vertexTarget
    });

    expect(supportsTransformAxisConstraint(faceRotateSession, "x")).toBe(true);
    expect(supportsTransformAxisConstraint(faceRotateSession, "y")).toBe(false);
    expect(supportsTransformAxisConstraint(faceRotateSession, "z")).toBe(false);

    expect(supportsTransformAxisConstraint(edgeScaleSession, "x")).toBe(true);
    expect(supportsTransformAxisConstraint(edgeScaleSession, "y")).toBe(false);
    expect(supportsTransformAxisConstraint(edgeScaleSession, "z")).toBe(true);

    expect(supportsTransformAxisConstraint(vertexTranslateSession, "x")).toBe(
      true
    );
    expect(supportsTransformAxisConstraint(vertexTranslateSession, "y")).toBe(
      true
    );
    expect(supportsTransformAxisConstraint(vertexTranslateSession, "z")).toBe(
      true
    );
  });

  it("only enables local axis toggling on supported transform targets", () => {
    const brush = createBoxBrush({
      id: "brush-local-axis"
    });
    const path = createScenePath({
      id: "path-local-axis",
      points: [
        {
          id: "path-local-point-a",
          position: {
            x: -2,
            y: 0,
            z: 0
          }
        },
        {
          id: "path-local-point-b",
          position: {
            x: 1,
            y: 0,
            z: 3
          }
        }
      ]
    });
    const playerStart = createPlayerStartEntity({
      id: "entity-local-axis-player",
      position: {
        x: 1,
        y: 0,
        z: 1
      },
      yawDegrees: 45
    });
    const document = {
      ...createEmptySceneDocument(),
      brushes: {
        [brush.id]: brush
      },
      paths: {
        [path.id]: path
      },
      entities: {
        [playerStart.id]: playerStart
      }
    };

    const brushTarget = resolveTransformTarget(document, {
      kind: "brushes",
      ids: [brush.id]
    }).target;
    const faceTarget = resolveTransformTarget(
      document,
      {
        kind: "brushFace",
        brushId: brush.id,
        faceId: "posX"
      },
      "face"
    ).target;
    const entityTarget = resolveTransformTarget(document, {
      kind: "entities",
      ids: [playerStart.id]
    }).target;
    const pathPointTarget = resolveTransformTarget(document, {
      kind: "pathPoint",
      pathId: path.id,
      pointId: path.points[0].id
    }).target;

    if (brushTarget === null || brushTarget.kind !== "brush") {
      throw new Error("Expected a brush transform target.");
    }

    if (faceTarget === null || faceTarget.kind !== "brushFace") {
      throw new Error("Expected a face transform target.");
    }

    if (entityTarget === null || entityTarget.kind !== "entity") {
      throw new Error("Expected an entity transform target.");
    }

    if (pathPointTarget === null || pathPointTarget.kind !== "pathPoint") {
      throw new Error("Expected a path point transform target.");
    }

    const brushTranslateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target: brushTarget
    });
    const brushScaleSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "scale",
      target: brushTarget
    });
    const faceRotateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "rotate",
      target: faceTarget
    });
    const entityTranslateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target: entityTarget
    });
    const pathPointTranslateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target: pathPointTarget
    });

    expect(
      supportsLocalTransformAxisConstraint(brushTranslateSession, "z")
    ).toBe(true);
    expect(supportsLocalTransformAxisConstraint(brushScaleSession, "z")).toBe(
      false
    );
    expect(supportsLocalTransformAxisConstraint(faceRotateSession, "x")).toBe(
      false
    );
    expect(
      supportsLocalTransformAxisConstraint(entityTranslateSession, "x")
    ).toBe(true);
    expect(
      supportsTransformAxisConstraint(pathPointTranslateSession, "z")
    ).toBe(true);
    expect(
      supportsLocalTransformAxisConstraint(pathPointTranslateSession, "z")
    ).toBe(false);
  });

  it("commits translated path points through the shared transform command path", () => {
    const path = createScenePath({
      id: "path-transform-main",
      points: [
        {
          id: "path-transform-point-a",
          position: {
            x: -1,
            y: 0,
            z: 0
          }
        },
        {
          id: "path-transform-point-b",
          position: {
            x: 1,
            y: 0,
            z: 1
          }
        }
      ]
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Path Transform Fixture" }),
        paths: {
          [path.id]: path
        }
      }
    });
    const target = resolveTransformTarget(store.getState().document, {
      kind: "pathPoint",
      pathId: path.id,
      pointId: path.points[1].id
    }).target;

    if (target === null || target.kind !== "pathPoint") {
      throw new Error("Expected a path point transform target.");
    }

    const translateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target
    });

    translateSession.preview = {
      kind: "pathPoint",
      position: {
        x: 4,
        y: 2,
        z: -3
      }
    };

    store.executeCommand(
      createCommitTransformSessionCommand(
        store.getState().document,
        translateSession
      )
    );

    expect(
      store.getState().document.paths[path.id]?.points[1]?.position
    ).toEqual({
      x: 4,
      y: 2,
      z: -3
    });
    expect(store.getState().selection).toEqual({
      kind: "pathPoint",
      pathId: path.id,
      pointId: path.points[1].id
    });

    expect(store.undo()).toBe(true);
    expect(
      store.getState().document.paths[path.id]?.points[1]?.position
    ).toEqual(path.points[1].position);

    expect(store.redo()).toBe(true);
    expect(
      store.getState().document.paths[path.id]?.points[1]?.position
    ).toEqual({
      x: 4,
      y: 2,
      z: -3
    });
  });

  it("commits whitebox box rotate and scale transforms with undo and redo", () => {
    const brush = createBoxBrush({
      id: "brush-transform-main",
      center: {
        x: 1.25,
        y: 1.5,
        z: -0.75
      },
      size: {
        x: 2.5,
        y: 2,
        z: 4
      }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Brush Transform Fixture" }),
        brushes: {
          [brush.id]: brush
        }
      }
    });
    const target = resolveTransformTarget(store.getState().document, {
      kind: "brushes",
      ids: [brush.id]
    }).target;

    if (target === null || target.kind !== "brush") {
      throw new Error("Expected a whitebox box transform target.");
    }

    const rotateSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "rotate",
      target
    });

    rotateSession.preview = {
      kind: "brush",
      center: {
        ...brush.center
      },
      rotationDegrees: {
        x: 0,
        y: 37.5,
        z: 12.5
      },
      size: {
        ...brush.size
      },
      geometry: target.initialGeometry
    };

    store.executeCommand(
      createCommitTransformSessionCommand(
        store.getState().document,
        rotateSession
      )
    );

    expect(store.getState().document.brushes[brush.id].rotationDegrees).toEqual(
      {
        x: 0,
        y: 37.5,
        z: 12.5
      }
    );

    const scaleTarget = resolveTransformTarget(store.getState().document, {
      kind: "brushes",
      ids: [brush.id]
    }).target;

    if (scaleTarget === null || scaleTarget.kind !== "brush") {
      throw new Error(
        "Expected a whitebox box transform target after rotation."
      );
    }

    const scaleSession = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "scale",
      target: scaleTarget
    });

    scaleSession.preview = {
      kind: "brush",
      center: {
        ...brush.center
      },
      rotationDegrees: {
        x: 0,
        y: 37.5,
        z: 12.5
      },
      size: {
        x: 3.25,
        y: 1.75,
        z: 5.5
      },
      geometry: scaleTarget.initialGeometry
    };

    store.executeCommand(
      createCommitTransformSessionCommand(
        store.getState().document,
        scaleSession
      )
    );

    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      rotationDegrees: {
        x: 0,
        y: 37.5,
        z: 12.5
      },
      size: {
        x: 3.25,
        y: 1.75,
        z: 5.5
      }
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      rotationDegrees: {
        x: 0,
        y: 37.5,
        z: 12.5
      },
      size: {
        x: 2.5,
        y: 2,
        z: 4
      }
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toEqual(brush);

    expect(store.redo()).toBe(true);
    expect(store.redo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      rotationDegrees: {
        x: 0,
        y: 37.5,
        z: 12.5
      },
      size: {
        x: 3.25,
        y: 1.75,
        z: 5.5
      }
    });
  });

  it("commits a face transform preview and restores it through undo/redo", () => {
    const brush = createBoxBrush({
      id: "brush-face-transform",
      center: { x: 0, y: 1, z: 0 },
      size: { x: 2, y: 2, z: 2 }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Face Transform Fixture" }),
        brushes: {
          [brush.id]: brush
        }
      }
    });
    const target = resolveTransformTarget(
      store.getState().document,
      {
        kind: "brushFace",
        brushId: brush.id,
        faceId: "posX"
      },
      "face"
    ).target;

    if (target === null || target.kind !== "brushFace") {
      throw new Error("Expected a whitebox face transform target.");
    }

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target
    });

    session.preview = {
      kind: "brush",
      center: { x: 0.5, y: 1, z: 0 },
      rotationDegrees: { x: 0, y: 0, z: 0 },
      size: { x: 3, y: 2, z: 2 },
      geometry: createBoxBrush({ size: { x: 3, y: 2, z: 2 } }).geometry
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      center: { x: 0.5, y: 1, z: 0 },
      size: { x: 3, y: 2, z: 2 }
    });
    expect(store.getState().selection).toEqual({
      kind: "brushFace",
      brushId: brush.id,
      faceId: "posX"
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toEqual(brush);

    expect(store.redo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      center: { x: 0.5, y: 1, z: 0 },
      size: { x: 3, y: 2, z: 2 }
    });
  });

  it("commits a vertex transform preview and preserves vertex selection through undo/redo", () => {
    const brush = createBoxBrush({
      id: "brush-vertex-transform",
      center: { x: 0, y: 1, z: 0 },
      size: { x: 2, y: 2, z: 2 }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Vertex Transform Fixture" }),
        brushes: {
          [brush.id]: brush
        }
      }
    });
    const target = resolveTransformTarget(
      store.getState().document,
      {
        kind: "brushVertex",
        brushId: brush.id,
        vertexId: "posX_posY_posZ"
      },
      "vertex"
    ).target;

    if (target === null || target.kind !== "brushVertex") {
      throw new Error("Expected a whitebox vertex transform target.");
    }

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target
    });

    session.preview = {
      kind: "brush",
      center: { x: 0.5, y: 1.5, z: 0.5 },
      rotationDegrees: { x: 0, y: 0, z: 0 },
      size: { x: 3, y: 3, z: 3 },
      geometry: createBoxBrush({ size: { x: 3, y: 3, z: 3 } }).geometry
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.brushes[brush.id]).toMatchObject({
      center: { x: 0.5, y: 1.5, z: 0.5 },
      size: { x: 3, y: 3, z: 3 }
    });
    expect(store.getState().selection).toEqual({
      kind: "brushVertex",
      brushId: brush.id,
      vertexId: "posX_posY_posZ"
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.brushes[brush.id]).toEqual(brush);
    expect(store.redo()).toBe(true);
    expect(store.getState().selection).toEqual({
      kind: "brushVertex",
      brushId: brush.id,
      vertexId: "posX_posY_posZ"
    });
  });

  it("commits deformed vertex geometry without forcing all vertices onto box extents", () => {
    const brush = createBoxBrush({
      id: "brush-vertex-deform",
      center: { x: 0, y: 0, z: 0 },
      size: { x: 2, y: 2, z: 2 }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Vertex Deform Fixture" }),
        brushes: {
          [brush.id]: brush
        }
      }
    });
    const target = resolveTransformTarget(
      store.getState().document,
      {
        kind: "brushVertex",
        brushId: brush.id,
        vertexId: "posX_posY_posZ"
      },
      "vertex"
    ).target;

    if (target === null || target.kind !== "brushVertex") {
      throw new Error("Expected a whitebox vertex transform target.");
    }

    const deformedGeometry = cloneBoxBrushGeometry(
      target.initialGeometry as ReturnType<typeof cloneBoxBrushGeometry>
    );
    deformedGeometry.vertices.posX_posY_posZ = {
      ...deformedGeometry.vertices.posX_posY_posZ,
      x: deformedGeometry.vertices.posX_posY_posZ.x + 1
    };

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target
    });

    session.preview = {
      kind: "brush",
      center: { ...target.initialCenter },
      rotationDegrees: { ...target.initialRotationDegrees },
      size: { ...target.initialSize },
      geometry: deformedGeometry
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    const committedBrush = store.getState().document.brushes[brush.id];
    expect(
      getBoxBrushLocalVertexPosition(committedBrush, "posX_posY_posZ").x
    ).toBe(2);
    expect(
      getBoxBrushLocalVertexPosition(committedBrush, "posX_posY_negZ").x
    ).toBe(1);
  });

  it("commits a model instance translate/rotate/scale transform with undo and redo", () => {
    const modelInstance = createModelInstance({
      id: "model-instance-main",
      assetId: modelAsset.id,
      position: {
        x: 0,
        y: 1,
        z: 0
      },
      rotationDegrees: {
        x: 0,
        y: 0,
        z: 0
      },
      scale: {
        x: 1,
        y: 1,
        z: 1
      }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Transform Fixture" }),
        assets: {
          [modelAsset.id]: modelAsset
        },
        modelInstances: {
          [modelInstance.id]: modelInstance
        }
      }
    });
    const target = resolveTransformTarget(store.getState().document, {
      kind: "modelInstances",
      ids: [modelInstance.id]
    }).target;

    if (target === null || target.kind !== "modelInstance") {
      throw new Error("Expected a model instance transform target.");
    }

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "scale",
      target
    });

    session.preview = {
      kind: "modelInstance",
      position: {
        x: 4,
        y: 1,
        z: -2
      },
      rotationDegrees: {
        x: 0,
        y: 90,
        z: 0
      },
      scale: {
        x: 1.5,
        y: 2,
        z: 1.5
      }
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(
      store.getState().document.modelInstances[modelInstance.id]
    ).toMatchObject({
      position: {
        x: 4,
        y: 1,
        z: -2
      },
      rotationDegrees: {
        x: 0,
        y: 90,
        z: 0
      },
      scale: {
        x: 1.5,
        y: 2,
        z: 1.5
      }
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.modelInstances[modelInstance.id]).toEqual(
      modelInstance
    );

    expect(store.redo()).toBe(true);
    expect(
      store.getState().document.modelInstances[modelInstance.id]
    ).toMatchObject({
      position: {
        x: 4,
        y: 1,
        z: -2
      },
      rotationDegrees: {
        x: 0,
        y: 90,
        z: 0
      },
      scale: {
        x: 1.5,
        y: 2,
        z: 1.5
      }
    });
  });

  it("commits a rotatable entity transform with undo and redo", () => {
    const playerStart = createPlayerStartEntity({
      id: "entity-player-start-main",
      position: {
        x: 0,
        y: 0,
        z: 0
      },
      yawDegrees: 0
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Entity Transform Fixture" }),
        entities: {
          [playerStart.id]: playerStart
        }
      }
    });
    const target = resolveTransformTarget(store.getState().document, {
      kind: "entities",
      ids: [playerStart.id]
    }).target;

    if (target === null || target.kind !== "entity") {
      throw new Error("Expected an entity transform target.");
    }

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "rotate",
      target
    });

    session.preview = {
      kind: "entity",
      position: {
        x: 6,
        y: 0,
        z: -4
      },
      rotation: {
        kind: "yaw",
        yawDegrees: 90
      }
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.entities[playerStart.id]).toMatchObject({
      position: {
        x: 6,
        y: 0,
        z: -4
      },
      yawDegrees: 90
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.entities[playerStart.id]).toEqual(
      playerStart
    );

    expect(store.redo()).toBe(true);
    expect(store.getState().document.entities[playerStart.id]).toMatchObject({
      position: {
        x: 6,
        y: 0,
        z: -4
      },
      yawDegrees: 90
    });
  });

  it("resolves same-kind multi targets with averaged pivots and deterministic active ids", () => {
    const brushA = createBoxBrush({
      id: "brush-multi-a",
      center: {
        x: -2,
        y: 1,
        z: 4
      }
    });
    const brushB = createBoxBrush({
      id: "brush-multi-b",
      center: {
        x: 4,
        y: 3,
        z: -2
      }
    });
    const modelInstanceA = createModelInstance({
      id: "model-multi-a",
      assetId: modelAsset.id,
      position: {
        x: -3,
        y: 0,
        z: 1
      }
    });
    const modelInstanceB = createModelInstance({
      id: "model-multi-b",
      assetId: modelAsset.id,
      position: {
        x: 5,
        y: 2,
        z: -1
      }
    });
    const entityA = createPlayerStartEntity({
      id: "entity-multi-a",
      position: {
        x: -4,
        y: 0,
        z: 0
      }
    });
    const entityB = createPlayerStartEntity({
      id: "entity-multi-b",
      position: {
        x: 2,
        y: 0,
        z: 6
      }
    });
    const document = {
      ...createEmptySceneDocument(),
      assets: {
        [modelAsset.id]: modelAsset
      },
      brushes: {
        [brushA.id]: brushA,
        [brushB.id]: brushB
      },
      entities: {
        [entityA.id]: entityA,
        [entityB.id]: entityB
      },
      modelInstances: {
        [modelInstanceA.id]: modelInstanceA,
        [modelInstanceB.id]: modelInstanceB
      }
    };

    const brushTarget = resolveTransformTarget(
      document,
      {
        kind: "brushes",
        ids: [brushA.id, brushB.id]
      },
      "object",
      brushA.id
    ).target;
    const modelTarget = resolveTransformTarget(
      document,
      {
        kind: "modelInstances",
        ids: [modelInstanceA.id, modelInstanceB.id]
      },
      "object",
      modelInstanceA.id
    ).target;
    const entityTarget = resolveTransformTarget(
      document,
      {
        kind: "entities",
        ids: [entityA.id, entityB.id]
      },
      "object",
      entityA.id
    ).target;

    expect(brushTarget).toMatchObject({
      kind: "brushes",
      activeBrushId: brushA.id,
      initialPivot: {
        x: 1,
        y: 2,
        z: 1
      }
    });
    expect(modelTarget).toMatchObject({
      kind: "modelInstances",
      activeModelInstanceId: modelInstanceA.id,
      initialPivot: {
        x: 1,
        y: 1,
        z: 0
      }
    });
    expect(entityTarget).toMatchObject({
      kind: "entities",
      activeEntityId: entityA.id,
      initialPivot: {
        x: -1,
        y: 0,
        z: 3
      }
    });
  });

  it("commits a multi-brush translate transform in one undoable command", () => {
    const brushA = createBoxBrush({
      id: "brush-batch-translate-a",
      center: {
        x: 0,
        y: 1,
        z: 0
      }
    });
    const brushB = createBoxBrush({
      id: "brush-batch-translate-b",
      center: {
        x: 6,
        y: 2,
        z: -4
      }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Multi Brush Translate" }),
        brushes: {
          [brushA.id]: brushA,
          [brushB.id]: brushB
        }
      }
    });
    const selection = {
      kind: "brushes" as const,
      ids: [brushA.id, brushB.id]
    };
    const target = resolveTransformTarget(
      store.getState().document,
      selection
    ).target;

    if (target === null || target.kind !== "brushes") {
      throw new Error("Expected a multi-brush transform target.");
    }

    store.setSelection(selection);

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "translate",
      target
    });

    session.preview = {
      kind: "brushes",
      pivot: {
        x: target.initialPivot.x + 2,
        y: target.initialPivot.y,
        z: target.initialPivot.z - 1
      },
      items: target.items.map((item) => ({
        brushId: item.brushId,
        center: {
          x: item.initialCenter.x + 2,
          y: item.initialCenter.y,
          z: item.initialCenter.z - 1
        },
        rotationDegrees: {
          ...item.initialRotationDegrees
        },
        size: {
          ...item.initialSize
        },
        geometry: cloneBoxBrushGeometry(
          item.initialGeometry as ReturnType<typeof cloneBoxBrushGeometry>
        )
      }))
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.brushes[brushA.id].center).toEqual({
      x: 2,
      y: 1,
      z: -1
    });
    expect(store.getState().document.brushes[brushB.id].center).toEqual({
      x: 8,
      y: 2,
      z: -5
    });
    expect(store.getState().selection).toEqual(selection);

    expect(store.undo()).toBe(true);
    expect(store.getState().document.brushes[brushA.id].center).toEqual(
      brushA.center
    );
    expect(store.getState().document.brushes[brushB.id].center).toEqual(
      brushB.center
    );

    expect(store.redo()).toBe(true);
    expect(store.getState().document.brushes[brushA.id].center).toEqual({
      x: 2,
      y: 1,
      z: -1
    });
    expect(store.getState().document.brushes[brushB.id].center).toEqual({
      x: 8,
      y: 2,
      z: -5
    });
  });

  it("commits a multi-model-instance scale transform with undo and redo", () => {
    const modelInstanceA = createModelInstance({
      id: "model-batch-scale-a",
      assetId: modelAsset.id,
      position: {
        x: -1,
        y: 0,
        z: 0
      }
    });
    const modelInstanceB = createModelInstance({
      id: "model-batch-scale-b",
      assetId: modelAsset.id,
      position: {
        x: 1,
        y: 0,
        z: 0
      }
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Multi Model Scale" }),
        assets: {
          [modelAsset.id]: modelAsset
        },
        modelInstances: {
          [modelInstanceA.id]: modelInstanceA,
          [modelInstanceB.id]: modelInstanceB
        }
      }
    });
    const selection = {
      kind: "modelInstances" as const,
      ids: [modelInstanceA.id, modelInstanceB.id]
    };
    const target = resolveTransformTarget(
      store.getState().document,
      selection
    ).target;

    if (target === null || target.kind !== "modelInstances") {
      throw new Error("Expected a multi-model transform target.");
    }

    store.setSelection(selection);

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "scale",
      target
    });

    session.preview = {
      kind: "modelInstances",
      pivot: {
        ...target.initialPivot
      },
      items: [
        {
          modelInstanceId: modelInstanceA.id,
          position: {
            x: -2,
            y: 0,
            z: 0
          },
          rotationDegrees: {
            ...modelInstanceA.rotationDegrees
          },
          scale: {
            x: 2,
            y: 2,
            z: 2
          }
        },
        {
          modelInstanceId: modelInstanceB.id,
          position: {
            x: 2,
            y: 0,
            z: 0
          },
          rotationDegrees: {
            ...modelInstanceB.rotationDegrees
          },
          scale: {
            x: 2,
            y: 2,
            z: 2
          }
        }
      ]
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.modelInstances[modelInstanceA.id]).toMatchObject({
      position: {
        x: -2,
        y: 0,
        z: 0
      },
      scale: {
        x: 2,
        y: 2,
        z: 2
      }
    });
    expect(store.getState().document.modelInstances[modelInstanceB.id]).toMatchObject({
      position: {
        x: 2,
        y: 0,
        z: 0
      },
      scale: {
        x: 2,
        y: 2,
        z: 2
      }
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.modelInstances[modelInstanceA.id]).toEqual(
      modelInstanceA
    );
    expect(store.getState().document.modelInstances[modelInstanceB.id]).toEqual(
      modelInstanceB
    );

    expect(store.redo()).toBe(true);
    expect(store.getState().document.modelInstances[modelInstanceA.id]).toMatchObject({
      position: {
        x: -2,
        y: 0,
        z: 0
      },
      scale: {
        x: 2,
        y: 2,
        z: 2
      }
    });
  });

  it("commits a multi-entity rotate transform when the selected kinds support it", () => {
    const entityA = createPlayerStartEntity({
      id: "entity-batch-rotate-a",
      position: {
        x: -2,
        y: 0,
        z: 0
      },
      yawDegrees: 0
    });
    const entityB = createPlayerStartEntity({
      id: "entity-batch-rotate-b",
      position: {
        x: 2,
        y: 0,
        z: 0
      },
      yawDegrees: 0
    });
    const store = createEditorStore({
      initialDocument: {
        ...createEmptySceneDocument({ name: "Multi Entity Rotate" }),
        entities: {
          [entityA.id]: entityA,
          [entityB.id]: entityB
        }
      }
    });
    const selection = {
      kind: "entities" as const,
      ids: [entityA.id, entityB.id]
    };
    const target = resolveTransformTarget(
      store.getState().document,
      selection
    ).target;

    if (target === null || target.kind !== "entities") {
      throw new Error("Expected a multi-entity transform target.");
    }

    expect(supportsTransformOperation(target, "rotate")).toBe(true);
    store.setSelection(selection);

    const session = createTransformSession({
      source: "keyboard",
      sourcePanelId: "topLeft",
      operation: "rotate",
      target
    });

    session.preview = {
      kind: "entities",
      pivot: {
        ...target.initialPivot
      },
      items: [
        {
          entityId: entityA.id,
          position: {
            x: 0,
            y: 0,
            z: 2
          },
          rotation: {
            kind: "yaw",
            yawDegrees: 90
          }
        },
        {
          entityId: entityB.id,
          position: {
            x: 0,
            y: 0,
            z: -2
          },
          rotation: {
            kind: "yaw",
            yawDegrees: 90
          }
        }
      ]
    };

    store.executeCommand(
      createCommitTransformSessionCommand(store.getState().document, session)
    );

    expect(store.getState().document.entities[entityA.id]).toMatchObject({
      position: {
        x: 0,
        y: 0,
        z: 2
      },
      yawDegrees: 90
    });
    expect(store.getState().document.entities[entityB.id]).toMatchObject({
      position: {
        x: 0,
        y: 0,
        z: -2
      },
      yawDegrees: 90
    });

    expect(store.undo()).toBe(true);
    expect(store.getState().document.entities[entityA.id]).toEqual(entityA);
    expect(store.getState().document.entities[entityB.id]).toEqual(entityB);
  });

  it("disables unsupported mixed-capability entity rotation for batch selections", () => {
    const playerStart = createPlayerStartEntity({
      id: "entity-mixed-player-start"
    });
    const triggerVolume = createTriggerVolumeEntity({
      id: "entity-mixed-trigger-volume"
    });
    const document = {
      ...createEmptySceneDocument(),
      entities: {
        [playerStart.id]: playerStart,
        [triggerVolume.id]: triggerVolume
      }
    };
    const target = resolveTransformTarget(document, {
      kind: "entities",
      ids: [playerStart.id, triggerVolume.id]
    }).target;

    if (target === null || target.kind !== "entities") {
      throw new Error("Expected a mixed entity batch target.");
    }

    expect(supportsTransformOperation(target, "translate")).toBe(true);
    expect(supportsTransformOperation(target, "rotate")).toBe(false);
    expect(supportsTransformOperation(target, "scale")).toBe(false);
  });
});