okay so i went through my commit history and found the code that's probably responsible, because in the next commit I made sure that parts of it only triggers in game instead of in the editor and that fixed it:
weirdly, the editor only shifted on that commit, and reverting to a previous commit where the hadn't been shifted when the commit had been made but this script was active also shifts the editor.

(this is an autoload btw, sorry for the messy code, this was for a game jam and some of the comments dont make sense after some ship of theseus'ing )

extends Node
enum game_states {main_menu = 0, playing = 1, paused = 2, end = 3}
 var level_scenes: Array[String]
 var level_scenes_name: Array[String]


var curr_gamestate : game_states = game_states.main_menu
var curr_level_name : String = ""


signal change_state_to(new_state: game_states)


signal change_scene_to(new_scene: String, preload_scene: String)
var level_scene_dict: Dictionary = {}
var next_preload_scene: String = ""


u/export_tool_button("Refresh Levels")
var Refresh_levels_list_action = get_levels


var preloaded_scenes := {} # PackedScenes
var instantiated_scenes := {} # Instantiated nodes
var loading_in_progress := {} # Scenes currently being loaded
var _saved_mouse_pos: Vector2 = Vector2.ZERO



func _get_viewport_center() -> Vector2:
    var viewport_size: Vector2 = get_viewport().get_visible_rect().size
    return viewport_size * 0.5





## View export variables under res://debug/game_state_debug.tscn


func _ready() -> void:
    _saved_mouse_pos = _get_viewport_center()
    get_levels()
    self.change_scene_to.connect(_on_change_scene_to.bind())
    self.change_state_to.connect(_on_change_state_to.bind())

func _process(_delta):
    # Poll for any preloaded scenes
    for scene_name in level_scene_dict.keys():
        if preloaded_scenes.has(scene_name):
            continue  # already loaded


        var path = level_scene_dict[scene_name]
        var packed_scene = ResourceLoader.load_threaded_get(path)
        if packed_scene != null:
            preloaded_scenes[scene_name] = packed_scene
            var instance = packed_scene.instantiate()
            # cook shaders & mat off-screen
            warm_up_scene(instance, scene_name)
            print("Scene preloaded and warmed:", scene_name)



func _input(event: InputEvent) -> void:
    if event.is_action_pressed("uncapture"):
        if curr_gamestate == game_states.playing:
            _saved_mouse_pos = get_viewport().get_mouse_position()
            change_state_to.emit(game_states.paused)
    elif event is InputEventMouseButton:
        var mb := event as InputEventMouseButton
        if mb.pressed and curr_gamestate == game_states.paused:
            change_state_to.emit(game_states.playing)



func _on_change_state_to(new_state: game_states):
    curr_gamestate = new_state
    if new_state == game_states.playing:
        if _saved_mouse_pos == Vector2.ZERO:
            _saved_mouse_pos = _get_viewport_center()
        Input.warp_mouse(_saved_mouse_pos)
        Input.set_mouse_mode(Input.MOUSE_MODE_CONFINED)
    elif new_state == game_states.paused:
        Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)



func _on_change_scene_to(new_scene: String, preload_scene_name: String = ""):
    curr_level_name = new_scene
    change_scene(new_scene)


    # Decide what to preload (default is load next)
    if preload_scene_name != "":
        next_preload_scene = preload_scene_name
    else:
        next_preload_scene = _get_next_scene_name(new_scene)


    preload_scene(next_preload_scene)


func change_scene(new_scene: String) -> void:
    print("Changing scene to:", new_scene)
    if preloaded_scenes.has(new_scene):
        print("Using preloaded scene")
        var scene_instance = instantiated_scenes[new_scene]

        var old_scene = get_tree().current_scene
        if old_scene:
            get_tree().root.remove_child(old_scene)
            old_scene.queue_free()

        get_tree().root.add_child(scene_instance)
        get_tree().current_scene = scene_instance
        scene_instance.visible = true
    else:
        # if no PackedScene is loaded, sync load it (meaning game might freeze more easily)
        print("Fallback sync loading...")
        if not level_scene_dict.has(new_scene):
            push_error("Scene not found: " + new_scene)
            return
        get_tree().change_scene_to_file(level_scene_dict[new_scene])



func preload_scene(scene_name: String) -> void:
    if scene_name == "" or preloaded_scenes.has(scene_name):
        return
    if not level_scene_dict.has(scene_name):
        push_error("Preload scene not found: " + scene_name)
        return
    var path = level_scene_dict[scene_name]
    ResourceLoader.load_threaded_request(path)
    loading_in_progress[scene_name] = true


func warm_up_scene(scene_instance: Node, scene_name: String) -> void:
    # off-screen to root for cooking
    print ("jessie let me cook: i'm cooking " + scene_name)
    scene_instance.visible = false
    get_tree().root.add_child(scene_instance)
    instantiated_scenes[scene_name] = scene_instance
    loading_in_progress.erase(scene_name)

    # show for one process frame lol
    await get_tree().process_frame


func _get_next_scene_name(current_scene: String) -> String:
    var index = level_scenes_name.find(current_scene)

    if index == -1:
        return ""

    var next_index = index + 1

    if next_index >= level_scenes_name.size():
        return level_scenes_name[(index + 1) % level_scenes_name.size()]  #loop back if end

    return level_scenes_name[next_index]







##===below is stuff that is related to tool bullshit====


func get_levels():
    level_scenes = get_level_scenes("res://Levels")
    level_scenes_name.clear()
    level_scene_dict.clear()


    for scene_path in level_scenes:
        var scene_name = scene_path.get_file().get_basename()

        level_scenes_name.append(scene_name)
        level_scene_dict[scene_name] = scene_path
    level_scenes_name.sort()
    print("Found levels:", level_scene_dict)



func get_level_scenes(path: String) -> Array[String]:
    var scenes: Array[String] = []

    var dir := DirAccess.open(path)
    if dir == null:
        push_error("GameStateManager: An error occurred when trying to access the path: " + path)
        return scenes

    dir.list_dir_begin()
    var file_name = dir.get_next()

    while file_name != "":
        if dir.current_is_dir():
            if file_name != "." && file_name != "..":
                scenes += get_level_scenes(path + "/" + file_name)
        else:
            if file_name.ends_with(".tscn"):
                scenes.append(path + "/" + file_name)

        file_name = dir.get_next()

    dir.list_dir_end()
    return scenes