How do I properly reload a scene asset without duplicating entities?

[atornity]

I'm trying to do some super basic saving/loading/reloading of scenes.

TLDR: I get duplicate entities when reloading a scene after saving it via a system.

Consider the following code:

fn setup(mut commands: Commands) {
    commands.spawn(Counter(0));
}

fn load(
    mut commands: Commands,
    server: Res<AssetServer>,
    roots: Query<Entity, (Without<Parent>, Or<(With<Counter>, With<DynamicSceneRoot>)>)>,
) {
    // despawn scene entities
    for entity in &roots {
        commands.entity(entity).despawn_recursive();
    }

    // load and spawn the scene
    server.reload("scene.scn.ron");
    let scene = server.load("scene.scn.ron");
    commands.spawn(DynamicSceneRoot(scene));
}

fn save(
    world: &mut World,
    state: &mut SystemState<(Query<Entity, With<Counter>>, Res<AppTypeRegistry>)>,
) {
    let (query, type_registry) = state.get(world);

    let mut scene = DynamicSceneBuilder::from_world(world)
        .deny_all_resources()
        // don't serialize the parent since it doesn't point to a valid entity
        .deny_component::<Parent>()
        .extract_entities(query.iter())
        .remove_empty_entities()
        .build();

    let type_registry = type_registry.read();
    let serialized_scene = scene.serialize(&type_registry).unwrap();

    IoTaskPool::get()
        .spawn(async move {
            File::create(format!("assets/scene.scn.ron"))
                .and_then(|mut file| file.write(serialized_scene.as_bytes()))
                .expect("Error while writing scene to file");
        })
        .detach();
}

I want to recursively despawn the entities in the scene before spawning it, the root will be Counter if the scene has not been loaded or DynamicSceneRoot if it is already loaded.

Then I want to reload or load the scene depending on if it's already loaded and then spawn the loaded scene. This shouldn't result in duplicate entities since we despawned everything prior. right?

This kind off works, when the load system runs, the scene get reloaded from the file. However if I save the scene using the save system, and then try to load it again, I get two instances of Counter entities. This is despite despawning all the entities before loading. If I then run the load system once more, the duplicate entity disappears and everything is fine.

Interestingly, if I edit the scene asset in the code editor rather than saving it via the save system, it seems to work as expected when I reload it.

This is very confusing to me and seems quite inconsistent. Here's the rest of the code if interested: https://gist.github.com/atornity/bd735c4b755a63a33c7632ac8ab084d1

[atornity]

I changed the load system with the following:

fn load(
    mut commands: Commands,
    server: Res<AssetServer>,
    roots: Query<Entity, (Without<Parent>, With<Counter>)>,
) {
    let scene = server.load("scene.scn.ron");
    server.reload("scene.scn.ron");
    if !server.is_loaded(scene.id()) {
        for entity in &roots {
            commands.entity(entity).despawn_recursive();
        }
        commands.spawn(DynamicSceneRoot(scene));
    }
}

It seems to sometimes work now, but it's super weird. If the first thing I do when the program starts is load then it works with no duplicate entities. However if I save first, then it won't work and I get duplicate entities again.