accessing entity mutably in a query when using World

[bananaturtlesandwich]

i'm trying to edit a scene by swapping materials before spawning it into the world but since the world is mutably borrowed for the query it can't be mutably borrowed again to sort out components on the entity

fn spawn(
    mut commands: Commands,
    stuff: Res<Stuff>,
    mut gltfs: ResMut<Assets<Scene>>,
    mut standard: ResMut<Assets<StandardMaterial>>,
    mut overlay: ResMut<Assets<bevy::pbr::ExtendedMaterial<StandardMaterial, material::Overlay>>>,
) {
    let scene = gltfs.get_mut(&stuff.model).unwrap();
    // query borrows world mutably
    for (ent, handle) in scene
        .world
        .query::<(Entity, &Handle<StandardMaterial>)>()
        .iter(&scene.world)
    {
        if let Some(mat) = standard.remove(handle) {
            // also borrows world mutably so causes compilation error
            let mut entity = scene.world.entity_mut(ent);
            entity.remove::<Handle<StandardMaterial>>();
            entity.insert(overlay.add(bevy::pbr::ExtendedMaterial {
                base: mat,
                extension: material::Overlay {},
            }));
        }
    }
    commands.spawn(
        SceneBundle {
            scene: bucket.model.clone_weak(),
            ..default()
        },
    );
}

this is solved in normal systems by deferring using commands but don't think this is an option here
i can't run a system within the world since it requires resources from the outer world where the material assets resources are

fn spawn(
    mut commands: Commands,
    bucket: Res<Bucket>,
    mut gltfs: ResMut<Assets<Scene>>,
    mut standard: ResMut<Assets<StandardMaterial>>,
    mut overlay: ResMut<Assets<bevy::pbr::ExtendedMaterial<StandardMaterial, material::Overlay>>>,
) {
    use bevy::ecs::system::RunSystemOnce;
    let scene = gltfs.get_mut(&bucket.model).unwrap();
    scene.world.run_system_once(material);
    commands.spawn(
        SceneBundle {
            scene: bucket.model.clone_weak(),
            ..default()
        },
    );
}

fn material(
    mut commands: Commands,
    // these don't exist in the scene world so the system panics
    // *******************************************
    mut standard: ResMut<Assets<StandardMaterial>>,
    mut overlay: ResMut<Assets<bevy::pbr::ExtendedMaterial<StandardMaterial, material::Overlay>>>,
    // *******************************************
    mat: Query<(Entity, &Handle<StandardMaterial>)>,
) {
    for (ent, mat) in &mat {
        if let Some(mat) = standard.remove(mat) {
            let mut entity = commands.entity(ent);
            entity.remove::<Handle<StandardMaterial>>();
            entity.insert(overlay.add(bevy::pbr::ExtendedMaterial {
                base: mat,
                extension: material::Overlay {},
            }));
        }
    }
}

any ideas on how to solve this?

[bananaturtlesandwich]

ended up using SystemState to essentially run a system with access to the outer world resource

let mut system: bevy::ecs::system::SystemState<(
    Commands,
    Query<(Entity, &Handle<StandardMaterial>)>,
)> = bevy::ecs::system::SystemState::new(&mut scene.world);
let (mut scene_commands, handles) = system.get_mut(&mut scene.world);
for (ent, handle) in &handles {
    if let Some(mat) = standard.remove(handle) {
        let mut entity = scene_commands.entity(ent);
        entity.remove::<Handle<StandardMaterial>>();
        entity.insert(overlay.add(bevy::pbr::ExtendedMaterial {
            base: mat,
            extension: material::Overlay {},
        }));
    }
}
system.apply(&mut scene.world);