kcl_lib/execution/

artifact.rs

use ahash::AHashMap;
use ahash::AHashSet;
use indexmap::IndexMap;
use kcl_api::NodePath;
use kcl_api::artifact::*;
use kittycad_modeling_cmds::EnableSketchMode;
use kittycad_modeling_cmds::FaceIsPlanar;
use kittycad_modeling_cmds::ModelingCmd;
use kittycad_modeling_cmds::ok_response::OkModelingCmdResponse;
use kittycad_modeling_cmds::shared::ExtrusionFaceCapType;
use kittycad_modeling_cmds::websocket::BatchResponse;
use kittycad_modeling_cmds::websocket::OkWebSocketResponseData;
use kittycad_modeling_cmds::websocket::WebSocketResponse;
use kittycad_modeling_cmds::{self as kcmc};
use serde::Serialize;
use uuid::Uuid;

use crate::KclError;
use crate::ModuleId;
use crate::NodePathExt;
use crate::SourceRange;
use crate::errors::KclErrorDetails;
use crate::execution::ArtifactId;
use crate::execution::CameraLook;
use crate::execution::CameraView;
use crate::execution::NamedViewValue;
use crate::execution::Orientation;
use crate::execution::Projection;
use crate::execution::Visibility;
use crate::execution::cmd_id_ref_to_artifact_id;
use crate::execution::geometry::PlaneInfo;
use crate::execution::state::ModuleInfoMap;
use crate::front::Constraint;
use crate::modules::ModulePath;
use crate::parsing::ast::types::BodyItem;
use crate::parsing::ast::types::ImportPath;
use crate::parsing::ast::types::ImportSelector;
use crate::parsing::ast::types::Node;
use crate::parsing::ast::types::Program;
use crate::std::sketch::build_reverse_region_mapping;

#[cfg(test)]
pub(crate) mod mermaid_tests;
#[cfg(test)]
mod tests;

macro_rules! internal_error {
    ($range:expr, $($rest:tt)*) => {{
        let message = format!($($rest)*);
        debug_assert!(false, "{}", &message);
        return Err(KclError::new_internal(KclErrorDetails::new(message, vec![$range])));
    }};
}

/// A command that may create or update artifacts on the TS side.  Because
/// engine commands are batched, we don't have the response yet when these are
/// created.
#[derive(Debug, Clone, PartialEq, Serialize, ts_rs::TS)]
#[ts(export_to = "Artifact.ts")]
#[serde(rename_all = "camelCase")]
pub struct ArtifactCommand {
    /// Identifier of the command that can be matched with its response.
    pub cmd_id: Uuid,
    /// The source range that's the boundary of calling the standard
    /// library, not necessarily the true source range of the command.
    pub range: SourceRange,
    /// The engine command.  Each artifact command is backed by an engine
    /// command.  In the future, we may need to send information to the TS side
    /// without an engine command, in which case, we would make this field
    /// optional. Imported file commands retain paths and format but omit raw
    /// file bytes after the command has been sent to the engine.
    pub command: ModelingCmd,
    /// Extra artifact identity needed when an engine clone represents a KCL
    /// solid whose body artifact ID differs from its engine entity ID.
    #[serde(skip_serializing_if = "Option::is_none")]
    #[ts(skip)]
    pub(crate) entity_clone_info: Option<EntityCloneInfo>,
    /// Whether this command should be omitted when deriving the semantic
    /// artifact graph. Query-only commands can still be useful in command
    /// snapshots without becoming frontend selection artifacts.
    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
    pub omit_from_graph: bool,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct EntityCloneInfo {
    pub source_artifact_id: ArtifactId,
    pub result_artifact_id: ArtifactId,
    /// The engine entity whose children describe the source body's topology.
    /// Pattern copies have their own root and child IDs, but retain the
    /// topology of the body from which they were patterned.
    pub source_topology_id: ArtifactId,
}

pub(super) fn artifact_plane_info(info: &PlaneInfo) -> ArtifactPlaneInfo {
    ArtifactPlaneInfo {
        origin: artifact_point3d(info.origin),
        x_axis: artifact_point3d(info.x_axis),
        y_axis: artifact_point3d(info.y_axis),
        z_axis: artifact_point3d(info.z_axis),
    }
}

fn artifact_point3d(point: crate::execution::Point3d) -> ArtifactPoint3d {
    ArtifactPoint3d {
        x: point.x,
        y: point.y,
        z: point.z,
        units: point.units,
    }
}

/// Builds the artifact for a named view.
///
/// The runtime value uses kcl-lib's camera and visibility types. The artifact
/// uses the kcl-api types that correspond to them, so this function converts
/// every field.
///
/// The value holds a baseline and one exception list, while the artifact holds
/// separate `show_ids` and `hide_ids`. The baseline decides which of those two
/// lists the exception becomes, and the other list is left empty: under a `Show`
/// baseline the excepted objects are the hidden ones, and under a `Hide`
/// baseline they are the only visible ones.
///
/// Each match below is exhaustive. A variant added to one of kcl-lib's enums
/// therefore fails to compile here instead of reaching a consumer as a
/// different variant.
pub(crate) fn named_view_artifact(view: &NamedViewValue, code_ref: CodeRef) -> NamedViewArtifact {
    let (show_ids, hide_ids) = match view.baseline() {
        Visibility::Show => (Vec::new(), view.except_ids().to_vec()),
        Visibility::Hide => (view.except_ids().to_vec(), Vec::new()),
    };

    NamedViewArtifact {
        id: view.artifact_id(),
        name: view.name().to_owned(),
        camera: artifact_camera_view(view.camera()),
        baseline: artifact_visibility(view.baseline()),
        show_ids,
        hide_ids,
        code_ref,
    }
}

fn artifact_camera_view(camera: &CameraView) -> ArtifactCameraView {
    ArtifactCameraView {
        look: artifact_camera_look(camera.look()),
        target: camera.target().copied().map(artifact_point3d),
        // The value already stores millimeters; this reads the number in the
        // unit the wire model documents rather than trusting the tag.
        distance: camera.distance().map(|distance| distance.to_mm()),
        projection: artifact_projection(camera.projection()),
    }
}

fn artifact_camera_look(look: &CameraLook) -> ArtifactCameraLook {
    match look {
        CameraLook::Oriented { orientation } => ArtifactCameraLook::Oriented {
            orientation: artifact_orientation(*orientation),
        },
        CameraLook::Directed { direction, up } => ArtifactCameraLook::Directed {
            direction: artifact_point3d(*direction),
            up: artifact_point3d(*up),
        },
    }
}

fn artifact_orientation(orientation: Orientation) -> ArtifactOrientation {
    match orientation {
        Orientation::Front => ArtifactOrientation::Front,
        Orientation::Back => ArtifactOrientation::Back,
        Orientation::Left => ArtifactOrientation::Left,
        Orientation::Right => ArtifactOrientation::Right,
        Orientation::Top => ArtifactOrientation::Top,
        Orientation::Bottom => ArtifactOrientation::Bottom,
        Orientation::Isometric => ArtifactOrientation::Isometric,
    }
}

fn artifact_projection(projection: Projection) -> ArtifactProjection {
    match projection {
        Projection::Orthographic => ArtifactProjection::Orthographic,
        Projection::Perspective => ArtifactProjection::Perspective,
    }
}

fn artifact_visibility(visibility: Visibility) -> ArtifactVisibility {
    match visibility {
        Visibility::Show => ArtifactVisibility::Show,
        Visibility::Hide => ArtifactVisibility::Hide,
    }
}

fn artifact_sweep_method(method: kcmc::shared::ExtrudeMethod) -> ArtifactSweepMethod {
    match method {
        kcmc::shared::ExtrudeMethod::New => ArtifactSweepMethod::New,
        kcmc::shared::ExtrudeMethod::Merge => ArtifactSweepMethod::Merge,
        _ => ArtifactSweepMethod::Merge,
    }
}

fn edge_cut_sub_type(cut_type: kcmc::shared::CutType) -> EdgeCutSubType {
    match cut_type {
        kcmc::shared::CutType::Fillet => EdgeCutSubType::Fillet,
        kcmc::shared::CutType::Chamfer => EdgeCutSubType::Chamfer,
    }
}

fn edge_cut_sub_type_v2(cut_type: kcmc::shared::CutTypeV2) -> EdgeCutSubType {
    match cut_type {
        kcmc::shared::CutTypeV2::Fillet { .. } => EdgeCutSubType::Fillet,
        kcmc::shared::CutTypeV2::Chamfer { .. } => EdgeCutSubType::Chamfer,
        kcmc::shared::CutTypeV2::Custom { .. } => EdgeCutSubType::Custom,
        _ => EdgeCutSubType::Custom,
    }
}

pub(crate) fn sketch_block_constraint_type(constraint: &Constraint) -> SketchBlockConstraintType {
    match constraint {
        Constraint::Coincident { .. } => SketchBlockConstraintType::Coincident,
        Constraint::Distance { .. } => SketchBlockConstraintType::Distance,
        Constraint::Diameter { .. } => SketchBlockConstraintType::Diameter,
        Constraint::EqualRadius { .. } => SketchBlockConstraintType::EqualRadius,
        Constraint::Fixed { .. } => SketchBlockConstraintType::Fixed,
        Constraint::HorizontalDistance { .. } => SketchBlockConstraintType::HorizontalDistance,
        Constraint::VerticalDistance { .. } => SketchBlockConstraintType::VerticalDistance,
        Constraint::Horizontal { .. } => SketchBlockConstraintType::Horizontal,
        Constraint::LinesEqualLength { .. } => SketchBlockConstraintType::LinesEqualLength,
        Constraint::Midpoint(..) => SketchBlockConstraintType::Midpoint,
        Constraint::Parallel { .. } => SketchBlockConstraintType::Parallel,
        Constraint::Perpendicular { .. } => SketchBlockConstraintType::Perpendicular,
        Constraint::Radius { .. } => SketchBlockConstraintType::Radius,
        Constraint::Symmetric { .. } => SketchBlockConstraintType::Symmetric,
        Constraint::Tangent { .. } => SketchBlockConstraintType::Tangent,
        Constraint::Vertical { .. } => SketchBlockConstraintType::Vertical,
        Constraint::Angle(..) => SketchBlockConstraintType::Angle,
    }
}

/// Merge the new artifact into the old one, returning a replacement when the
/// artifact types differ.
fn merge_artifacts(old: &mut Artifact, new: Artifact) -> Option<Artifact> {
    match old {
        Artifact::CompositeSolid(a) => merge_composite_solid(a, new),
        Artifact::Plane(a) => merge_plane(a, new),
        Artifact::Path(a) => merge_path(a, new),
        Artifact::Segment(a) => merge_segment(a, new),
        Artifact::Solid2d(_) => Some(new),
        Artifact::PrimitiveFace(_) => Some(new),
        Artifact::PrimitiveEdge(_) => Some(new),
        Artifact::StartSketchOnFace { .. } => Some(new),
        Artifact::StartSketchOnPlane { .. } => Some(new),
        Artifact::SketchBlock { .. } => Some(new),
        Artifact::SketchBlockConstraint { .. } => Some(new),
        Artifact::PlaneOfFace { .. } => Some(new),
        Artifact::Sweep(a) => merge_sweep(a, new),
        Artifact::Wall(a) => merge_wall(a, new),
        Artifact::Cap(a) => merge_cap(a, new),
        Artifact::SweepEdge(_) => Some(new),
        Artifact::EdgeCut(a) => merge_edge_cut(a, new),
        Artifact::EdgeCutEdge(_) => Some(new),
        Artifact::Helix(a) => merge_helix(a, new),
        Artifact::ImportedGeometry(_) => Some(new),
        Artifact::GdtAnnotation(a) => merge_gdt_annotation(a, new),
        // One `view::named` call supplies every field, so nothing accumulates.
        // Replacing wholesale keeps `show_ids`/`hide_ids` exactly as that call
        // wrote them; unioning would mix in ids from an earlier execution of the
        // same call site, which reuses the same artifact id.
        Artifact::NamedView(_) => Some(new),
        Artifact::Pattern(a) => merge_pattern(a, new),
    }
}

fn merge_composite_solid(old: &mut CompositeSolid, new: Artifact) -> Option<Artifact> {
    let Artifact::CompositeSolid(new) = new else {
        return Some(new);
    };
    merge_ids(&mut old.solid_ids, new.solid_ids);
    merge_ids(&mut old.tool_ids, new.tool_ids);
    merge_opt_id(&mut old.composite_solid_id, new.composite_solid_id);
    merge_ids(&mut old.pattern_ids, new.pattern_ids);
    old.output_index = new.output_index;
    old.consumed = new.consumed;
    None
}

fn merge_plane(old: &mut Plane, new: Artifact) -> Option<Artifact> {
    let Artifact::Plane(new) = new else { return Some(new) };
    merge_ids(&mut old.path_ids, new.path_ids);
    None
}

fn merge_path(old: &mut Path, new: Artifact) -> Option<Artifact> {
    let Artifact::Path(new) = new else { return Some(new) };
    merge_opt_id(&mut old.sweep_id, new.sweep_id);
    merge_opt_id(&mut old.trajectory_sweep_id, new.trajectory_sweep_id);
    merge_ids(&mut old.seg_ids, new.seg_ids);
    merge_opt_id(&mut old.solid2d_id, new.solid2d_id);
    merge_opt_id(&mut old.composite_solid_id, new.composite_solid_id);
    merge_opt_id(&mut old.sketch_block_id, new.sketch_block_id);
    merge_opt_id(&mut old.origin_path_id, new.origin_path_id);
    merge_opt_id(&mut old.inner_path_id, new.inner_path_id);
    merge_opt_id(&mut old.outer_path_id, new.outer_path_id);
    merge_ids(&mut old.pattern_ids, new.pattern_ids);
    old.consumed = new.consumed;
    None
}

fn merge_segment(old: &mut Segment, new: Artifact) -> Option<Artifact> {
    let Artifact::Segment(new) = new else { return Some(new) };
    // Clone provenance is sticky across partial updates: unlike
    // `merge_opt_id`, a missing new value preserves the existing source.
    old.source_segment_id = new.source_segment_id.or(old.source_segment_id);
    merge_opt_id(&mut old.original_seg_id, new.original_seg_id);
    merge_opt_id(&mut old.surface_id, new.surface_id);
    merge_ids(&mut old.edge_ids, new.edge_ids);
    merge_opt_id(&mut old.edge_cut_id, new.edge_cut_id);
    merge_ids(&mut old.common_surface_ids, new.common_surface_ids);
    None
}

fn merge_sweep(old: &mut Sweep, new: Artifact) -> Option<Artifact> {
    let Artifact::Sweep(new) = new else { return Some(new) };
    merge_ids(&mut old.surface_ids, new.surface_ids);
    merge_ids(&mut old.edge_ids, new.edge_ids);
    // Clone provenance is sticky across partial updates: unlike
    // `merge_opt_id`, a missing new value preserves the existing source.
    old.source_sweep_id = new.source_sweep_id.or(old.source_sweep_id);
    merge_opt_id(&mut old.trajectory_id, new.trajectory_id);
    merge_ids(&mut old.pattern_ids, new.pattern_ids);
    old.consumed = new.consumed;
    None
}

fn merge_wall(old: &mut Wall, new: Artifact) -> Option<Artifact> {
    let Artifact::Wall(new) = new else { return Some(new) };
    merge_ids(&mut old.edge_cut_edge_ids, new.edge_cut_edge_ids);
    merge_ids(&mut old.path_ids, new.path_ids);
    None
}

fn merge_cap(old: &mut Cap, new: Artifact) -> Option<Artifact> {
    let Artifact::Cap(new) = new else { return Some(new) };
    merge_ids(&mut old.edge_cut_edge_ids, new.edge_cut_edge_ids);
    merge_ids(&mut old.path_ids, new.path_ids);
    None
}

fn merge_edge_cut(old: &mut EdgeCut, new: Artifact) -> Option<Artifact> {
    let Artifact::EdgeCut(new) = new else { return Some(new) };
    merge_opt_id(&mut old.surface_id, new.surface_id);
    merge_ids(&mut old.edge_ids, new.edge_ids);
    None
}

fn merge_helix(old: &mut Helix, new: Artifact) -> Option<Artifact> {
    let Artifact::Helix(new) = new else { return Some(new) };
    merge_opt_id(&mut old.axis_id, new.axis_id);
    merge_opt_id(&mut old.trajectory_sweep_id, new.trajectory_sweep_id);
    old.consumed = new.consumed;
    None
}

fn merge_gdt_annotation(old: &mut GdtAnnotationArtifact, new: Artifact) -> Option<Artifact> {
    let Artifact::GdtAnnotation(new) = new else {
        return Some(new);
    };
    old.code_ref = new.code_ref;
    None
}

fn merge_pattern(old: &mut Pattern, new: Artifact) -> Option<Artifact> {
    let Artifact::Pattern(new) = new else { return Some(new) };
    merge_ids(&mut old.copy_ids, new.copy_ids);
    merge_ids(&mut old.copy_face_ids, new.copy_face_ids);
    merge_ids(&mut old.copy_edge_ids, new.copy_edge_ids);
    None
}

#[derive(Debug, Clone)]
struct ImportCodeRef {
    node_path: NodePath,
    range: SourceRange,
}

fn import_statement_code_refs(
    ast: &Node<Program>,
    module_infos: &ModuleInfoMap,
    programs: &crate::execution::ProgramLookup,
    cached_body_items: usize,
) -> AHashMap<ModuleId, ImportCodeRef> {
    let mut code_refs = AHashMap::default();
    for body_item in &ast.body {
        let BodyItem::ImportStatement(import_stmt) = body_item else {
            continue;
        };
        if !matches!(import_stmt.selector, ImportSelector::None { .. }) {
            continue;
        }
        let Some(module_id) = module_id_for_import_path(module_infos, &import_stmt.path) else {
            continue;
        };
        let range = SourceRange::from(import_stmt);
        let node_path = NodePath::from_range(programs, cached_body_items, range).unwrap_or_default();
        code_refs.entry(module_id).or_insert(ImportCodeRef { node_path, range });
    }
    code_refs
}

fn module_id_for_import_path(module_infos: &ModuleInfoMap, import_path: &ImportPath) -> Option<ModuleId> {
    let import_path = match import_path {
        ImportPath::Kcl { filename } => filename,
        ImportPath::Foreign { path } => path,
        ImportPath::Std { .. } => return None,
    };

    module_infos.iter().find_map(|(module_id, module_info)| {
        if let ModulePath::Local {
            original_import_path: Some(original_import_path),
            ..
        } = &module_info.path
            && original_import_path == import_path
        {
            return Some(*module_id);
        }
        None
    })
}

fn code_ref_for_range(
    programs: &crate::execution::ProgramLookup,
    cached_body_items: usize,
    range: SourceRange,
    import_code_refs: &AHashMap<ModuleId, ImportCodeRef>,
) -> (SourceRange, NodePath) {
    if let Some(code_ref) = import_code_refs.get(&range.module_id()) {
        return (code_ref.range, code_ref.node_path.clone());
    }

    (
        range,
        NodePath::from_range(programs, cached_body_items, range).unwrap_or_default(),
    )
}

/// Build the artifact graph from the artifact commands and the responses.  The
/// initial graph is the graph cached from a previous execution.  NodePaths of
/// `exec_artifacts` are filled in from the AST.
pub(super) fn build_artifact_graph(
    artifact_commands: &[ArtifactCommand],
    responses: &IndexMap<Uuid, WebSocketResponse>,
    ast: &Node<Program>,
    exec_artifacts: &mut IndexMap<ArtifactId, Artifact>,
    initial_graph: ArtifactGraph,
    programs: &crate::execution::ProgramLookup,
    module_infos: &ModuleInfoMap,
) -> Result<ArtifactGraph, KclError> {
    let (mut map, item_count) = initial_graph.into_parts();

    let mut path_to_plane_id_map = AHashMap::default();
    let mut current_plane_id = None;
    let import_code_refs = import_statement_code_refs(ast, module_infos, programs, item_count);
    let flattened_responses = flatten_modeling_command_responses(responses);
    let entity_clone_id_maps = build_entity_clone_id_maps(artifact_commands, &flattened_responses);

    // Fill in NodePaths for artifacts that were added directly to the map
    // during execution.
    for exec_artifact in exec_artifacts.values_mut() {
        // Note: We only have access to the new AST. So if these artifacts
        // somehow came from cached AST, this won't fill in anything.
        fill_in_node_paths(exec_artifact, programs, item_count, &import_code_refs);
    }

    for artifact_command in artifact_commands {
        if artifact_command.omit_from_graph {
            continue;
        }
        if let ModelingCmd::EnableSketchMode(EnableSketchMode { entity_id, .. }) = artifact_command.command {
            current_plane_id = Some(entity_id);
        }
        // If we get a start path command, we need to set the plane ID to the
        // current plane ID.
        // THIS IS THE ONLY THING WE CAN ASSUME IS ALWAYS SEQUENTIAL SINCE ITS PART OF THE
        // SAME ATOMIC COMMANDS BATCHING.
        if let ModelingCmd::StartPath(_) = artifact_command.command
            && let Some(plane_id) = current_plane_id
        {
            path_to_plane_id_map.insert(artifact_command.cmd_id, plane_id);
        }
        if let ModelingCmd::SketchModeDisable(_) = artifact_command.command {
            current_plane_id = None;
        }

        let artifact_updates = artifacts_to_update(
            &map,
            artifact_command,
            &flattened_responses,
            &entity_clone_id_maps,
            &path_to_plane_id_map,
            programs,
            item_count,
            exec_artifacts,
            &import_code_refs,
        )?;
        for artifact in artifact_updates {
            // Merge with existing artifacts.
            merge_artifact_into_map(&mut map, artifact);
        }
    }

    for exec_artifact in exec_artifacts.values() {
        merge_artifact_into_map(&mut map, exec_artifact.clone());
    }

    Ok(ArtifactGraph::from_parts(map, item_count + ast.body.len()))
}

/// These may have been created with placeholder `CodeRef`s because we didn't
/// have the entire AST available. Now we fill them in.
fn fill_in_node_paths(
    artifact: &mut Artifact,
    programs: &crate::execution::ProgramLookup,
    cached_body_items: usize,
    import_code_refs: &AHashMap<ModuleId, ImportCodeRef>,
) {
    match artifact {
        Artifact::StartSketchOnFace(face) if face.code_ref.node_path.is_empty() => {
            let (range, node_path) =
                code_ref_for_range(programs, cached_body_items, face.code_ref.range, import_code_refs);
            face.code_ref.range = range;
            face.code_ref.node_path = node_path;
        }
        Artifact::StartSketchOnPlane(plane) if plane.code_ref.node_path.is_empty() => {
            let (range, node_path) =
                code_ref_for_range(programs, cached_body_items, plane.code_ref.range, import_code_refs);
            plane.code_ref.range = range;
            plane.code_ref.node_path = node_path;
        }
        Artifact::SketchBlock(block) if block.code_ref.node_path.is_empty() => {
            let (range, node_path) =
                code_ref_for_range(programs, cached_body_items, block.code_ref.range, import_code_refs);
            block.code_ref.range = range;
            block.code_ref.node_path = node_path;
        }
        Artifact::SketchBlockConstraint(constraint) if constraint.code_ref.node_path.is_empty() => {
            constraint.code_ref.node_path =
                NodePath::from_range(programs, cached_body_items, constraint.code_ref.range).unwrap_or_default();
        }
        Artifact::GdtAnnotation(annotation) if annotation.code_ref.node_path.is_empty() => {
            let (range, node_path) =
                code_ref_for_range(programs, cached_body_items, annotation.code_ref.range, import_code_refs);
            annotation.code_ref.range = range;
            annotation.code_ref.node_path = node_path;
        }
        Artifact::NamedView(view) if view.code_ref.node_path.is_empty() => {
            let (range, node_path) =
                code_ref_for_range(programs, cached_body_items, view.code_ref.range, import_code_refs);
            view.code_ref.range = range;
            view.code_ref.node_path = node_path;
        }
        _ => {}
    }
}

/// Flatten the responses into a map of command IDs to modeling command
/// responses.  The raw responses from the engine contain batches.
fn flatten_modeling_command_responses(
    responses: &IndexMap<Uuid, WebSocketResponse>,
) -> AHashMap<Uuid, OkModelingCmdResponse> {
    let mut map = AHashMap::default();
    for (cmd_id, ws_response) in responses {
        let WebSocketResponse::Success(response) = ws_response else {
            // Response not successful.
            continue;
        };
        match &response.resp {
            OkWebSocketResponseData::Modeling { modeling_response } => {
                map.insert(*cmd_id, modeling_response.clone());
            }
            OkWebSocketResponseData::ModelingBatch { responses } =>
            {
                #[expect(
                    clippy::iter_over_hash_type,
                    reason = "Since we're moving entries to another unordered map, it's fine that the order is undefined"
                )]
                for (cmd_id, batch_response) in responses {
                    if let BatchResponse::Success {
                        response: modeling_response,
                    } = batch_response
                    {
                        map.insert(*cmd_id.as_ref(), modeling_response.clone());
                    }
                }
            }
            OkWebSocketResponseData::IceServerInfo { .. }
            | OkWebSocketResponseData::TrickleIce { .. }
            | OkWebSocketResponseData::SdpAnswer { .. }
            | OkWebSocketResponseData::Export { .. }
            | OkWebSocketResponseData::MetricsRequest { .. }
            | OkWebSocketResponseData::ModelingSessionData { .. }
            | OkWebSocketResponseData::Debug { .. }
            | OkWebSocketResponseData::Pong { .. } => {}
            _other => {}
        }
    }

    map
}

#[derive(Debug, Clone)]
struct PendingEntityCloneMapping {
    clone_cmd_id: Uuid,
    old_entity_id: Uuid,
    source_topology_id: Uuid,
    old_child_ids: Option<Vec<Uuid>>,
    source_topology_child_ids: Option<Vec<Uuid>>,
}

/// Build old->new entity ID maps for each clone command by pairing the
/// `EntityGetAllChildUuids` queries emitted by `std::clone`.
fn build_entity_clone_id_maps(
    artifact_commands: &[ArtifactCommand],
    responses: &AHashMap<Uuid, OkModelingCmdResponse>,
) -> AHashMap<Uuid, AHashMap<ArtifactId, ArtifactId>> {
    let mut clone_id_maps = AHashMap::default();
    let mut pending = Vec::new();

    for artifact_command in artifact_commands {
        match &artifact_command.command {
            ModelingCmd::EntityClone(kcmc::EntityClone { entity_id, .. }) => {
                let source_topology_id = artifact_command
                    .entity_clone_info
                    .map(|info| Uuid::from(info.source_topology_id))
                    .unwrap_or(*entity_id);
                pending.push(PendingEntityCloneMapping {
                    clone_cmd_id: artifact_command.cmd_id,
                    old_entity_id: *entity_id,
                    source_topology_id,
                    old_child_ids: None,
                    source_topology_child_ids: None,
                });
            }
            ModelingCmd::EntityGetAllChildUuids(kcmc::EntityGetAllChildUuids { entity_id, .. }) => {
                let Some(OkModelingCmdResponse::EntityGetAllChildUuids(child_ids_response)) =
                    responses.get(&artifact_command.cmd_id)
                else {
                    continue;
                };
                let child_ids = child_ids_response.entity_ids.clone();

                let mut completed_index = None;
                for index in (0..pending.len()).rev() {
                    let pending_map = &mut pending[index];
                    if let Some(old_child_ids) = &pending_map.old_child_ids
                        && *entity_id == pending_map.clone_cmd_id
                    {
                        let mut id_map = AHashMap::default();
                        id_map.insert(
                            ArtifactId::new(pending_map.old_entity_id),
                            ArtifactId::new(pending_map.clone_cmd_id),
                        );
                        for (old_id, new_id) in old_child_ids.iter().zip(child_ids.iter()) {
                            id_map.insert(ArtifactId::new(*old_id), ArtifactId::new(*new_id));
                        }
                        if pending_map.source_topology_id != pending_map.old_entity_id
                            && let Some(source_topology_child_ids) = &pending_map.source_topology_child_ids
                        {
                            for (source_id, new_id) in source_topology_child_ids.iter().zip(child_ids.iter()) {
                                id_map.insert(ArtifactId::new(*source_id), ArtifactId::new(*new_id));
                            }
                        }
                        clone_id_maps.insert(pending_map.clone_cmd_id, id_map);
                        completed_index = Some(index);
                        break;
                    }
                    if pending_map.old_child_ids.is_none() && *entity_id == pending_map.old_entity_id {
                        pending_map.old_child_ids = Some(child_ids.clone());
                        if pending_map.source_topology_id == pending_map.old_entity_id {
                            pending_map.source_topology_child_ids = Some(child_ids.clone());
                        }
                        break;
                    }
                    if pending_map.source_topology_child_ids.is_none() && *entity_id == pending_map.source_topology_id {
                        pending_map.source_topology_child_ids = Some(child_ids.clone());
                        break;
                    }
                }

                if let Some(index) = completed_index {
                    pending.swap_remove(index);
                }
            }
            _ => {}
        }
    }

    clone_id_maps
}

fn merge_artifact_into_map(map: &mut IndexMap<ArtifactId, Artifact>, new_artifact: Artifact) {
    fn is_primitive_artifact(artifact: &Artifact) -> bool {
        matches!(artifact, Artifact::PrimitiveFace(_) | Artifact::PrimitiveEdge(_))
    }

    let id = new_artifact.id();
    let Some(old_artifact) = map.get_mut(&id) else {
        // No old artifact exists.  Insert the new one.
        map.insert(id, new_artifact);
        return;
    };

    // Primitive lookups (faceId/edgeId) may resolve to an ID that already has
    // a richer artifact (for example Segment/Cap/Wall). Keep the existing node
    // to avoid erasing structural graph links.
    if is_primitive_artifact(&new_artifact) && !is_primitive_artifact(old_artifact) {
        return;
    }

    if let Some(replacement) = merge_artifacts(old_artifact, new_artifact) {
        *old_artifact = replacement;
    }
}

/// Merge the new IDs into the base vector, avoiding duplicates.  This is O(nm)
/// runtime.  Rationale is that most of the ID collections in the artifact graph
/// are pretty small, but we may want to change this in the future.
fn merge_ids(base: &mut Vec<ArtifactId>, new: Vec<ArtifactId>) {
    let original_len = base.len();
    for id in new {
        // Don't bother inspecting new items that we just pushed.
        let original_base = &base[..original_len];
        if !original_base.contains(&id) {
            base.push(id);
        }
    }
}

/// Merge optional Artifact ID
fn merge_opt_id(base: &mut Option<ArtifactId>, new: Option<ArtifactId>) {
    // Always use the new one, even if it clears it.
    *base = new;
}

fn remap_id_for_clone(id: ArtifactId, entity_id_map: &AHashMap<ArtifactId, ArtifactId>) -> ArtifactId {
    entity_id_map.get(&id).copied().unwrap_or(id)
}

fn remap_opt_id_for_clone(
    id: Option<ArtifactId>,
    entity_id_map: &AHashMap<ArtifactId, ArtifactId>,
) -> Option<ArtifactId> {
    id.map(|id| remap_id_for_clone(id, entity_id_map))
}

fn remap_ids_for_clone(ids: &[ArtifactId], entity_id_map: &AHashMap<ArtifactId, ArtifactId>) -> Vec<ArtifactId> {
    ids.iter()
        .copied()
        .map(|id| remap_id_for_clone(id, entity_id_map))
        .collect()
}

fn remap_mapped_ids_for_clone(ids: &[ArtifactId], entity_id_map: &AHashMap<ArtifactId, ArtifactId>) -> Vec<ArtifactId> {
    ids.iter().filter_map(|id| entity_id_map.get(id).copied()).collect()
}

fn add_composite_sweep_clone_id_mappings(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    clone_cmd_id: Uuid,
    entity_id_map: &mut AHashMap<ArtifactId, ArtifactId>,
) {
    let source_sweep_ids = artifacts
        .values()
        .filter_map(|artifact| {
            let Artifact::Sweep(sweep) = artifact else {
                return None;
            };
            if entity_id_map.contains_key(&sweep.id) {
                return None;
            }

            let has_mapped_topology = entity_id_map.contains_key(&sweep.path_id)
                || sweep.surface_ids.iter().any(|id| entity_id_map.contains_key(id))
                || sweep.edge_ids.iter().any(|id| entity_id_map.contains_key(id));
            has_mapped_topology.then_some(sweep.id)
        })
        .collect::<Vec<_>>();

    for source_sweep_id in source_sweep_ids {
        let source_uuid = Uuid::from(source_sweep_id);
        let cloned_sweep_id = ArtifactId::new(Uuid::new_v5(&clone_cmd_id, source_uuid.as_bytes()));
        entity_id_map.insert(source_sweep_id, cloned_sweep_id);
    }
}

fn remap_artifact_for_clone(
    artifact: &Artifact,
    entity_id_map: &AHashMap<ArtifactId, ArtifactId>,
    clone_code_ref: &CodeRef,
    clone_cmd_id: Uuid,
    source_root_id: ArtifactId,
) -> Artifact {
    match artifact {
        Artifact::CompositeSolid(source) => Artifact::CompositeSolid(CompositeSolid {
            id: remap_id_for_clone(source.id, entity_id_map),
            consumed: if source.id == source_root_id {
                false
            } else {
                source.consumed
            },
            sub_type: source.sub_type,
            // clone() returns one new top-level body, even when its source was
            // an indexed output or belonged to another composite solid.
            output_index: if source.id == source_root_id {
                None
            } else {
                source.output_index
            },
            solid_ids: remap_ids_for_clone(&source.solid_ids, entity_id_map),
            tool_ids: remap_ids_for_clone(&source.tool_ids, entity_id_map),
            pattern_ids: remap_mapped_ids_for_clone(&source.pattern_ids, entity_id_map),
            code_ref: clone_code_ref.clone(),
            composite_solid_id: if source.id == source_root_id {
                None
            } else {
                remap_opt_id_for_clone(source.composite_solid_id, entity_id_map)
            },
        }),
        Artifact::Plane(source) => Artifact::Plane(Plane {
            id: remap_id_for_clone(source.id, entity_id_map),
            path_ids: remap_ids_for_clone(&source.path_ids, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::Path(source) => Artifact::Path(Path {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            plane_id: remap_id_for_clone(source.plane_id, entity_id_map),
            seg_ids: remap_ids_for_clone(&source.seg_ids, entity_id_map),
            consumed: if source.id == source_root_id {
                false
            } else {
                source.consumed
            },
            sweep_id: remap_opt_id_for_clone(source.sweep_id, entity_id_map),
            trajectory_sweep_id: remap_opt_id_for_clone(source.trajectory_sweep_id, entity_id_map),
            solid2d_id: remap_opt_id_for_clone(source.solid2d_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
            composite_solid_id: remap_opt_id_for_clone(source.composite_solid_id, entity_id_map),
            sketch_block_id: remap_opt_id_for_clone(source.sketch_block_id, entity_id_map),
            origin_path_id: remap_opt_id_for_clone(source.origin_path_id, entity_id_map),
            inner_path_id: remap_opt_id_for_clone(source.inner_path_id, entity_id_map),
            outer_path_id: remap_opt_id_for_clone(source.outer_path_id, entity_id_map),
            pattern_ids: remap_mapped_ids_for_clone(&source.pattern_ids, entity_id_map),
        }),
        Artifact::Segment(source) => Artifact::Segment(Segment {
            id: remap_id_for_clone(source.id, entity_id_map),
            path_id: remap_id_for_clone(source.path_id, entity_id_map),
            source_segment_id: source.source_segment_id.or(Some(source.id)),
            original_seg_id: remap_opt_id_for_clone(source.original_seg_id, entity_id_map),
            surface_id: remap_opt_id_for_clone(source.surface_id, entity_id_map),
            edge_ids: remap_ids_for_clone(&source.edge_ids, entity_id_map),
            edge_cut_id: remap_opt_id_for_clone(source.edge_cut_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
            common_surface_ids: remap_ids_for_clone(&source.common_surface_ids, entity_id_map),
        }),
        Artifact::Solid2d(source) => Artifact::Solid2d(Solid2d {
            id: remap_id_for_clone(source.id, entity_id_map),
            path_id: remap_id_for_clone(source.path_id, entity_id_map),
        }),
        Artifact::PrimitiveFace(source) => Artifact::PrimitiveFace(PrimitiveFace {
            id: remap_id_for_clone(source.id, entity_id_map),
            solid_id: remap_id_for_clone(source.solid_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::PrimitiveEdge(source) => Artifact::PrimitiveEdge(PrimitiveEdge {
            id: remap_id_for_clone(source.id, entity_id_map),
            solid_id: remap_id_for_clone(source.solid_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::PlaneOfFace(source) => Artifact::PlaneOfFace(PlaneOfFace {
            id: remap_id_for_clone(source.id, entity_id_map),
            face_id: remap_id_for_clone(source.face_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::StartSketchOnFace(source) => Artifact::StartSketchOnFace(StartSketchOnFace {
            id: remap_id_for_clone(source.id, entity_id_map),
            face_id: remap_id_for_clone(source.face_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::StartSketchOnPlane(source) => Artifact::StartSketchOnPlane(StartSketchOnPlane {
            id: remap_id_for_clone(source.id, entity_id_map),
            plane_id: remap_id_for_clone(source.plane_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::SketchBlock(source) => Artifact::SketchBlock(SketchBlock {
            id: remap_id_for_clone(source.id, entity_id_map),
            standard_plane: source.standard_plane,
            plane_id: remap_opt_id_for_clone(source.plane_id, entity_id_map),
            plane_info: source.plane_info.clone(),
            path_id: remap_opt_id_for_clone(source.path_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
            sketch_id: source.sketch_id,
        }),
        Artifact::SketchBlockConstraint(source) => Artifact::SketchBlockConstraint(SketchBlockConstraint {
            id: remap_id_for_clone(source.id, entity_id_map),
            sketch_id: source.sketch_id,
            constraint_id: source.constraint_id,
            constraint_type: source.constraint_type,
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::Sweep(source) => Artifact::Sweep(Sweep {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            path_id: remap_id_for_clone(source.path_id, entity_id_map),
            surface_ids: remap_ids_for_clone(&source.surface_ids, entity_id_map),
            edge_ids: remap_ids_for_clone(&source.edge_ids, entity_id_map),
            code_ref: clone_code_ref.clone(),
            source_sweep_id: source.source_sweep_id.or(Some(source.id)),
            trajectory_id: remap_opt_id_for_clone(source.trajectory_id, entity_id_map),
            method: source.method,
            consumed: if source.id == source_root_id {
                false
            } else {
                source.consumed
            },
            pattern_ids: remap_mapped_ids_for_clone(&source.pattern_ids, entity_id_map),
        }),
        Artifact::Wall(source) => Artifact::Wall(Wall {
            id: remap_id_for_clone(source.id, entity_id_map),
            seg_id: remap_id_for_clone(source.seg_id, entity_id_map),
            edge_cut_edge_ids: remap_ids_for_clone(&source.edge_cut_edge_ids, entity_id_map),
            sweep_id: remap_id_for_clone(source.sweep_id, entity_id_map),
            path_ids: remap_ids_for_clone(&source.path_ids, entity_id_map),
            face_code_ref: source.face_code_ref.clone(),
            cmd_id: clone_cmd_id,
        }),
        Artifact::Cap(source) => Artifact::Cap(Cap {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            edge_cut_edge_ids: remap_ids_for_clone(&source.edge_cut_edge_ids, entity_id_map),
            sweep_id: remap_id_for_clone(source.sweep_id, entity_id_map),
            path_ids: remap_ids_for_clone(&source.path_ids, entity_id_map),
            face_code_ref: source.face_code_ref.clone(),
            cmd_id: clone_cmd_id,
        }),
        Artifact::SweepEdge(source) => Artifact::SweepEdge(SweepEdge {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            seg_id: remap_id_for_clone(source.seg_id, entity_id_map),
            cmd_id: clone_cmd_id,
            index: source.index,
            sweep_id: remap_id_for_clone(source.sweep_id, entity_id_map),
            common_surface_ids: remap_ids_for_clone(&source.common_surface_ids, entity_id_map),
        }),
        Artifact::EdgeCut(source) => Artifact::EdgeCut(EdgeCut {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            consumed_edge_id: remap_id_for_clone(source.consumed_edge_id, entity_id_map),
            edge_ids: remap_ids_for_clone(&source.edge_ids, entity_id_map),
            surface_id: remap_opt_id_for_clone(source.surface_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::EdgeCutEdge(source) => Artifact::EdgeCutEdge(EdgeCutEdge {
            id: remap_id_for_clone(source.id, entity_id_map),
            edge_cut_id: remap_id_for_clone(source.edge_cut_id, entity_id_map),
            surface_id: remap_id_for_clone(source.surface_id, entity_id_map),
        }),
        Artifact::Helix(source) => Artifact::Helix(Helix {
            id: remap_id_for_clone(source.id, entity_id_map),
            axis_id: remap_opt_id_for_clone(source.axis_id, entity_id_map),
            code_ref: clone_code_ref.clone(),
            trajectory_sweep_id: remap_opt_id_for_clone(source.trajectory_sweep_id, entity_id_map),
            consumed: if source.id == source_root_id {
                false
            } else {
                source.consumed
            },
        }),
        Artifact::ImportedGeometry(source) => Artifact::ImportedGeometry(ImportedGeometryArtifact {
            id: remap_id_for_clone(source.id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        Artifact::GdtAnnotation(source) => Artifact::GdtAnnotation(GdtAnnotationArtifact {
            id: remap_id_for_clone(source.id, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
        // A named view has no engine entity, so it can never appear in a
        // clone's id map, and `clone()` takes only a sketch, solid or imported
        // geometry as its source. This arm exists because the match is
        // exhaustive: returning the artifact unchanged makes it a no-op re-insert
        // rather than inventing a second view, which would carry a duplicate
        // name. The assertion is a tripwire if the assumption ever breaks.
        Artifact::NamedView(_) => {
            debug_assert!(false, "a named view is not reachable from a cloned body");
            artifact.clone()
        }
        Artifact::Pattern(source) => Artifact::Pattern(Pattern {
            id: remap_id_for_clone(source.id, entity_id_map),
            sub_type: source.sub_type,
            source_id: remap_id_for_clone(source.source_id, entity_id_map),
            copy_ids: remap_ids_for_clone(&source.copy_ids, entity_id_map),
            copy_face_ids: remap_ids_for_clone(&source.copy_face_ids, entity_id_map),
            copy_edge_ids: remap_ids_for_clone(&source.copy_edge_ids, entity_id_map),
            code_ref: clone_code_ref.clone(),
        }),
    }
}

fn pattern_source_ids(artifacts: &IndexMap<ArtifactId, Artifact>, source_id: ArtifactId) -> Vec<ArtifactId> {
    let mut source_ids = vec![source_id];

    if let Some(Artifact::Path(path)) = artifacts.get(&source_id) {
        if let Some(sweep_id) = path.sweep_id {
            source_ids.push(sweep_id);
        }
        if let Some(composite_solid_id) = path.composite_solid_id {
            source_ids.push(composite_solid_id);
        }
    }

    for artifact in artifacts.values() {
        match artifact {
            Artifact::Sweep(sweep) if sweep.path_id == source_id => source_ids.push(sweep.id),
            Artifact::CompositeSolid(composite)
                if composite.solid_ids.contains(&source_id) || composite.tool_ids.contains(&source_id) =>
            {
                source_ids.push(composite.id)
            }
            _ => {}
        }
    }

    let mut unique = Vec::new();
    merge_ids(&mut unique, source_ids);
    unique
}

fn pattern_source_body_id_for_copy(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    copy_id: ArtifactId,
) -> Option<ArtifactId> {
    artifacts.values().find_map(|artifact| {
        let Artifact::Pattern(pattern) = artifact else {
            return None;
        };
        if !pattern.copy_ids.contains(&copy_id) {
            return None;
        }

        pattern_source_ids(artifacts, pattern.source_id).into_iter().find(|id| {
            matches!(
                artifacts.get(id),
                Some(Artifact::Sweep(_) | Artifact::CompositeSolid(_))
            )
        })
    })
}

fn pattern_artifact_updates(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    pattern_id: ArtifactId,
    sub_type: PatternSubType,
    source_id: ArtifactId,
    face_edge_infos: &[kcmc::output::FaceEdgeInfo],
    code_ref: CodeRef,
) -> Vec<Artifact> {
    let copy_ids = face_edge_infos
        .iter()
        .map(|info| ArtifactId::new(info.object_id))
        .collect::<Vec<_>>();
    let copy_face_ids = face_edge_infos
        .iter()
        .flat_map(|info| info.faces.iter().copied().map(ArtifactId::new))
        .collect::<Vec<_>>();
    let copy_edge_ids = face_edge_infos
        .iter()
        .flat_map(|info| info.edges.iter().copied().map(ArtifactId::new))
        .collect::<Vec<_>>();

    let source_ids = pattern_source_ids(artifacts, source_id);
    let mut return_arr = vec![Artifact::Pattern(Pattern {
        id: pattern_id,
        sub_type,
        source_id,
        copy_ids,
        copy_face_ids,
        copy_edge_ids,
        code_ref,
    })];

    for source_id in source_ids {
        let Some(artifact) = artifacts.get(&source_id) else {
            continue;
        };
        match artifact {
            Artifact::Path(path) => {
                let mut new_path = path.clone();
                new_path.pattern_ids = vec![pattern_id];
                return_arr.push(Artifact::Path(new_path));
            }
            Artifact::Sweep(sweep) => {
                let mut new_sweep = sweep.clone();
                new_sweep.pattern_ids = vec![pattern_id];
                return_arr.push(Artifact::Sweep(new_sweep));
            }
            Artifact::CompositeSolid(composite) => {
                let mut new_composite = composite.clone();
                new_composite.pattern_ids = vec![pattern_id];
                return_arr.push(Artifact::CompositeSolid(new_composite));
            }
            _ => {}
        }
    }

    return_arr
}

fn is_single_target_self_subtract(target_ids: &[Uuid], tool_ids: &[Uuid]) -> bool {
    target_ids.len() == 1 && tool_ids.len() == 1 && target_ids[0] == tool_ids[0]
}

fn boolean_subtract_output_artifact_ids(
    cmd_id: ArtifactId,
    target_ids: &[Uuid],
    tool_ids: &[Uuid],
    extra_solid_ids: &[Uuid],
) -> Vec<ArtifactId> {
    if is_single_target_self_subtract(target_ids, tool_ids) {
        return Vec::new();
    }

    let mut output_ids = if target_ids.len() == 1 {
        vec![cmd_id]
    } else {
        Vec::new()
    };

    for extra_solid_id in extra_solid_ids {
        let artifact_id = ArtifactId::new(*extra_solid_id);
        if !output_ids.contains(&artifact_id) {
            output_ids.push(artifact_id);
        }
    }

    output_ids
}

fn update_consumed_csg_sweep(
    return_arr: &mut Vec<Artifact>,
    artifacts: &IndexMap<ArtifactId, Artifact>,
    sweep_id: ArtifactId,
    consumed_sweep_ids: &mut AHashSet<ArtifactId>,
) {
    if consumed_sweep_ids.insert(sweep_id)
        && let Some(Artifact::Sweep(sweep)) = artifacts.get(&sweep_id)
    {
        let mut new_sweep = sweep.clone();
        new_sweep.consumed = true;
        return_arr.push(Artifact::Sweep(new_sweep));
    }
}

fn mark_artifact_consumed_by_id(
    return_arr: &mut Vec<Artifact>,
    artifacts: &IndexMap<ArtifactId, Artifact>,
    artifact_id: ArtifactId,
    consumed_ids: &mut AHashSet<ArtifactId>,
) {
    let already_marked_as_consumed = !consumed_ids.insert(artifact_id);
    if already_marked_as_consumed {
        return;
    }

    let Some(artifact) = artifacts.get(&artifact_id) else {
        return;
    };

    match artifact {
        Artifact::CompositeSolid(composite) => {
            let mut new_composite = composite.clone();
            new_composite.consumed = true;
            return_arr.push(Artifact::CompositeSolid(new_composite));
        }
        Artifact::Path(path) => {
            let mut new_path = path.clone();
            new_path.consumed = true;
            return_arr.push(Artifact::Path(new_path));

            if let Some(sweep_id) = path.sweep_id {
                mark_artifact_consumed_by_id(return_arr, artifacts, sweep_id, consumed_ids);
            }
            if let Some(composite_solid_id) = path.composite_solid_id {
                mark_artifact_consumed_by_id(return_arr, artifacts, composite_solid_id, consumed_ids);
            }
        }
        Artifact::Sweep(sweep) => {
            let mut new_sweep = sweep.clone();
            new_sweep.consumed = true;
            return_arr.push(Artifact::Sweep(new_sweep));
        }
        Artifact::Helix(helix) => {
            let mut new_helix = helix.clone();
            new_helix.consumed = true;
            return_arr.push(Artifact::Helix(new_helix));
        }
        _ => {}
    }
}

fn mark_deleted_artifacts_consumed(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    object_ids: &std::collections::HashSet<Uuid>,
) -> Vec<Artifact> {
    let mut return_arr = Vec::new();
    let mut consumed_ids = AHashSet::default();

    // The order of iteration doesn't matter here, as all artifacts get marked as consumed.
    // Also the set comes from the API crate which uses HashSet.
    #[allow(clippy::iter_over_hash_type)]
    for object_id in object_ids {
        let artifact_id = ArtifactId::new(*object_id);
        mark_artifact_consumed_by_id(&mut return_arr, artifacts, artifact_id, &mut consumed_ids);
    }

    return_arr
}

fn update_csg_input_artifacts(
    return_arr: &mut Vec<Artifact>,
    artifacts: &IndexMap<ArtifactId, Artifact>,
    input_ids: &[ArtifactId],
    composite_solid_id: Option<ArtifactId>,
    consumed_sweep_ids: &mut AHashSet<ArtifactId>,
) {
    for input_id in input_ids {
        if let Some(artifact) = artifacts.get(input_id) {
            match artifact {
                Artifact::CompositeSolid(comp) => {
                    let mut new_comp = comp.clone();
                    new_comp.composite_solid_id = composite_solid_id;
                    new_comp.consumed = true;
                    return_arr.push(Artifact::CompositeSolid(new_comp));
                }
                Artifact::Path(path) => {
                    let mut new_path = path.clone();
                    new_path.composite_solid_id = composite_solid_id;

                    // We want to mark any sweeps of the path used in this operation
                    // as consumed. The path itself is already consumed by sweeping.
                    if let Some(sweep_id) = new_path.sweep_id {
                        update_consumed_csg_sweep(return_arr, artifacts, sweep_id, consumed_sweep_ids);
                    }

                    return_arr.push(Artifact::Path(new_path));
                }
                Artifact::Sweep(sweep) => {
                    update_consumed_csg_sweep(return_arr, artifacts, sweep.id, consumed_sweep_ids);
                }
                _ => {}
            }
        }
    }
}

fn mirror_3d_artifact_updates(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    original_solid_ids: &[Uuid],
    face_edge_infos: &[kcmc::output::FaceEdgeInfo],
    code_ref: CodeRef,
    range: SourceRange,
    cmd: &ModelingCmd,
) -> Result<Vec<Artifact>, KclError> {
    if original_solid_ids.len() != face_edge_infos.len() {
        internal_error!(
            range,
            "EntityMirrorAcross response has different number face edge info than original mirrored solids: cmd={cmd:?}, face_edge_infos={face_edge_infos:?}"
        );
    }

    let mut return_arr = Vec::new();
    for (face_edge_info, original_solid_id) in face_edge_infos.iter().zip(original_solid_ids) {
        let original_solid_id = ArtifactId::new(*original_solid_id);
        let mirrored_solid_id = ArtifactId::new(face_edge_info.object_id);
        let source_solid = match artifacts.get(&original_solid_id) {
            Some(Artifact::Path(path)) => path.sweep_id.and_then(|sweep_id| artifacts.get(&sweep_id)).or_else(|| {
                path.composite_solid_id
                    .and_then(|composite_id| artifacts.get(&composite_id))
            }),
            source => source,
        };
        match source_solid {
            Some(Artifact::Sweep(sweep)) => {
                let mut mirrored_sweep = sweep.clone();
                mirrored_sweep.id = mirrored_solid_id;
                mirrored_sweep.surface_ids = face_edge_info.faces.iter().copied().map(ArtifactId::new).collect();
                mirrored_sweep.edge_ids = face_edge_info.edges.iter().copied().map(ArtifactId::new).collect();
                mirrored_sweep.code_ref = code_ref.clone();
                mirrored_sweep.consumed = false;
                mirrored_sweep.pattern_ids = Vec::new();
                return_arr.push(Artifact::Sweep(mirrored_sweep));
            }
            Some(Artifact::CompositeSolid(composite)) => {
                let mut mirrored_composite = composite.clone();
                mirrored_composite.id = mirrored_solid_id;
                mirrored_composite.code_ref = code_ref.clone();
                mirrored_composite.consumed = false;
                mirrored_composite.composite_solid_id = None;
                mirrored_composite.pattern_ids = Vec::new();
                return_arr.push(Artifact::CompositeSolid(mirrored_composite));
            }
            Some(_) | None => continue,
        }
    }

    Ok(return_arr)
}

#[allow(clippy::too_many_arguments)]
fn artifacts_to_update(
    artifacts: &IndexMap<ArtifactId, Artifact>,
    artifact_command: &ArtifactCommand,
    responses: &AHashMap<Uuid, OkModelingCmdResponse>,
    entity_clone_id_maps: &AHashMap<Uuid, AHashMap<ArtifactId, ArtifactId>>,
    path_to_plane_id_map: &AHashMap<Uuid, Uuid>,
    programs: &crate::execution::ProgramLookup,
    cached_body_items: usize,
    exec_artifacts: &IndexMap<ArtifactId, Artifact>,
    import_code_refs: &AHashMap<ModuleId, ImportCodeRef>,
) -> Result<Vec<Artifact>, KclError> {
    let uuid = artifact_command.cmd_id;
    let response = responses.get(&uuid);

    // TODO: Build path-to-node from artifact_command source range.  Right now,
    // we're serializing an empty array, and the TS wrapper fills it in with the
    // correct value based on NodePath.
    let path_to_node = Vec::new();
    let range = artifact_command.range;
    let (code_ref_range, node_path) = code_ref_for_range(programs, cached_body_items, range, import_code_refs);
    let code_ref = CodeRef {
        range: code_ref_range,
        node_path,
        path_to_node,
    };

    let id = ArtifactId::new(uuid);
    let cmd = &artifact_command.command;

    match cmd {
        ModelingCmd::ImportFiles(_) => {
            return Ok(vec![Artifact::ImportedGeometry(ImportedGeometryArtifact {
                id,
                code_ref,
            })]);
        }
        ModelingCmd::MakePlane(_) => {
            if range.is_synthetic() {
                return Ok(Vec::new());
            }
            // If we're calling `make_plane` and the code range doesn't end at
            // `0` it's not a default plane, but a custom one from the
            // offsetPlane standard library function.
            return Ok(vec![Artifact::Plane(Plane {
                id,
                path_ids: Vec::new(),
                code_ref,
            })]);
        }
        ModelingCmd::FaceIsPlanar(FaceIsPlanar { object_id, .. }) => {
            return Ok(vec![Artifact::PlaneOfFace(PlaneOfFace {
                id,
                face_id: object_id.into(),
                code_ref,
            })]);
        }
        ModelingCmd::RemoveSceneObjects(remove) => {
            return Ok(mark_deleted_artifacts_consumed(artifacts, &remove.object_ids));
        }
        ModelingCmd::EnableSketchMode(EnableSketchMode { entity_id, .. }) => {
            let existing_plane = artifacts.get(&ArtifactId::new(*entity_id));
            match existing_plane {
                Some(Artifact::Wall(wall)) => {
                    return Ok(vec![Artifact::Wall(Wall {
                        id: entity_id.into(),
                        seg_id: wall.seg_id,
                        edge_cut_edge_ids: wall.edge_cut_edge_ids.clone(),
                        sweep_id: wall.sweep_id,
                        path_ids: wall.path_ids.clone(),
                        face_code_ref: wall.face_code_ref.clone(),
                        cmd_id: artifact_command.cmd_id,
                    })]);
                }
                Some(Artifact::Cap(cap)) => {
                    return Ok(vec![Artifact::Cap(Cap {
                        id: entity_id.into(),
                        sub_type: cap.sub_type,
                        edge_cut_edge_ids: cap.edge_cut_edge_ids.clone(),
                        sweep_id: cap.sweep_id,
                        path_ids: cap.path_ids.clone(),
                        face_code_ref: cap.face_code_ref.clone(),
                        cmd_id: artifact_command.cmd_id,
                    })]);
                }
                Some(_) | None => {
                    let path_ids = match existing_plane {
                        Some(Artifact::Plane(Plane { path_ids, .. })) => path_ids.clone(),
                        _ => Vec::new(),
                    };
                    // Create an entirely new plane
                    return Ok(vec![Artifact::Plane(Plane {
                        id: entity_id.into(),
                        path_ids,
                        code_ref,
                    })]);
                }
            }
        }
        ModelingCmd::StartPath(_) => {
            let mut return_arr = Vec::new();
            let current_plane_id = path_to_plane_id_map.get(&artifact_command.cmd_id).ok_or_else(|| {
                KclError::new_internal(KclErrorDetails::new(
                    format!("Expected a current plane ID when processing StartPath command, but we have none: {id:?}"),
                    vec![range],
                ))
            })?;
            let sketch_block_id = exec_artifacts
                .values()
                .find(|a| {
                    if let Artifact::SketchBlock(s) = a {
                        if let Some(path_id) = s.path_id {
                            path_id == id
                        } else {
                            false
                        }
                    } else {
                        false
                    }
                })
                .map(|a| a.id());
            return_arr.push(Artifact::Path(Path {
                id,
                sub_type: PathSubType::Sketch,
                plane_id: (*current_plane_id).into(),
                seg_ids: Vec::new(),
                sweep_id: None,
                trajectory_sweep_id: None,
                solid2d_id: None,
                code_ref,
                composite_solid_id: None,
                sketch_block_id,
                origin_path_id: None,
                inner_path_id: None,
                outer_path_id: None,
                pattern_ids: Vec::new(),
                consumed: false,
            }));
            let plane = artifacts.get(&ArtifactId::new(*current_plane_id));
            if let Some(Artifact::Plane(plane)) = plane {
                let plane_code_ref = plane.code_ref.clone();
                return_arr.push(Artifact::Plane(Plane {
                    id: (*current_plane_id).into(),
                    path_ids: vec![id],
                    code_ref: plane_code_ref,
                }));
            }
            if let Some(Artifact::Wall(wall)) = plane {
                return_arr.push(Artifact::Wall(Wall {
                    id: (*current_plane_id).into(),
                    seg_id: wall.seg_id,
                    edge_cut_edge_ids: wall.edge_cut_edge_ids.clone(),
                    sweep_id: wall.sweep_id,
                    path_ids: vec![id],
                    face_code_ref: wall.face_code_ref.clone(),
                    cmd_id: artifact_command.cmd_id,
                }));
            }
            if let Some(Artifact::Cap(cap)) = plane {
                return_arr.push(Artifact::Cap(Cap {
                    id: (*current_plane_id).into(),
                    sub_type: cap.sub_type,
                    edge_cut_edge_ids: cap.edge_cut_edge_ids.clone(),
                    sweep_id: cap.sweep_id,
                    path_ids: vec![id],
                    face_code_ref: cap.face_code_ref.clone(),
                    cmd_id: artifact_command.cmd_id,
                }));
            }
            return Ok(return_arr);
        }
        ModelingCmd::ClosePath(_) | ModelingCmd::ExtendPath(_) => {
            let path_id = ArtifactId::new(match cmd {
                ModelingCmd::ClosePath(c) => c.path_id,
                ModelingCmd::ExtendPath(e) => e.path.into(),
                _ => internal_error!(
                    range,
                    "Close or extend path command variant not handled: id={id:?}, cmd={cmd:?}"
                ),
            });
            let mut return_arr = Vec::new();
            return_arr.push(Artifact::Segment(Segment {
                id,
                path_id,
                source_segment_id: None,
                original_seg_id: None,
                surface_id: None,
                edge_ids: Vec::new(),
                edge_cut_id: None,
                code_ref,
                common_surface_ids: Vec::new(),
            }));
            let path = artifacts.get(&path_id);
            if let Some(Artifact::Path(path)) = path {
                let mut new_path = path.clone();
                new_path.seg_ids = vec![id];
                return_arr.push(Artifact::Path(new_path));
            }
            if let Some(OkModelingCmdResponse::ClosePath(close_path)) = response {
                return_arr.push(Artifact::Solid2d(Solid2d {
                    id: close_path.face_id.into(),
                    path_id,
                }));
                if let Some(Artifact::Path(path)) = path {
                    let mut new_path = path.clone();
                    new_path.solid2d_id = Some(close_path.face_id.into());
                    return_arr.push(Artifact::Path(new_path));
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::CreateRegion(kcmc::CreateRegion {
            object_id: origin_path_id,
            ..
        })
        | ModelingCmd::CreateRegionFromQueryPoint(kcmc::CreateRegionFromQueryPoint {
            object_id: origin_path_id,
            ..
        }) => {
            let mut return_arr = Vec::new();
            let origin_path = artifacts.get(&ArtifactId::new(*origin_path_id));
            let Some(Artifact::Path(path)) = origin_path else {
                internal_error!(
                    range,
                    "Expected to find an existing path for the origin path of CreateRegion or CreateRegionFromQueryPoint command, but found none: origin_path={origin_path:?}, cmd={cmd:?}"
                );
            };
            let region_path = |seg_ids, code_ref| {
                Artifact::Path(Path {
                    id,
                    sub_type: PathSubType::Region,
                    plane_id: path.plane_id,
                    seg_ids,
                    consumed: false,
                    sweep_id: None,
                    trajectory_sweep_id: None,
                    solid2d_id: None,
                    code_ref,
                    composite_solid_id: None,
                    sketch_block_id: None,
                    origin_path_id: Some(ArtifactId::new(*origin_path_id)),
                    inner_path_id: None,
                    outer_path_id: None,
                    pattern_ids: Vec::new(),
                })
            };
            // If we have a response, we can also create the segments in the
            // region.
            let Some(
                OkModelingCmdResponse::CreateRegion(kcmc::output::CreateRegion { region_mapping, .. })
                | OkModelingCmdResponse::CreateRegionFromQueryPoint(kcmc::output::CreateRegionFromQueryPoint {
                    region_mapping,
                    ..
                }),
            ) = response
            else {
                return_arr.push(region_path(Vec::new(), code_ref));
                return Ok(return_arr);
            };
            // Each key is a segment in the region. The value is the segment in
            // the original path. Build the reverse mapping.
            let original_segment_ids = path.seg_ids.iter().map(Uuid::from).collect::<Vec<_>>();
            let reverse = build_reverse_region_mapping(region_mapping, &original_segment_ids);
            let region_segment_ids = reverse
                .values()
                .flat_map(|region_segment_ids| region_segment_ids.iter().copied())
                .map(ArtifactId::new)
                .collect::<Vec<_>>();
            return_arr.push(region_path(region_segment_ids, code_ref.clone()));
            for (original_segment_id, region_segment_ids) in reverse.iter() {
                for segment_id in region_segment_ids {
                    return_arr.push(Artifact::Segment(Segment {
                        id: ArtifactId::new(*segment_id),
                        path_id: id,
                        source_segment_id: None,
                        original_seg_id: Some(ArtifactId::new(*original_segment_id)),
                        surface_id: None,
                        edge_ids: Vec::new(),
                        edge_cut_id: None,
                        code_ref: code_ref.clone(),
                        common_surface_ids: Vec::new(),
                    }))
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dGetFaceUuid(kcmc::Solid3dGetFaceUuid { object_id, .. }) => {
            let Some(OkModelingCmdResponse::Solid3dGetFaceUuid(face_uuid)) = response else {
                return Ok(Vec::new());
            };

            return Ok(vec![Artifact::PrimitiveFace(PrimitiveFace {
                id: face_uuid.face_id.into(),
                solid_id: (*object_id).into(),
                code_ref,
            })]);
        }
        ModelingCmd::Solid3dGetEdgeUuid(kcmc::Solid3dGetEdgeUuid { object_id, .. }) => {
            let Some(OkModelingCmdResponse::Solid3dGetEdgeUuid(edge_uuid)) = response else {
                return Ok(Vec::new());
            };

            return Ok(vec![Artifact::PrimitiveEdge(PrimitiveEdge {
                id: edge_uuid.edge_id.into(),
                solid_id: (*object_id).into(),
                code_ref,
            })]);
        }
        ModelingCmd::EntityLinearPatternTransform(pattern_cmd) => {
            let face_edge_infos = match response {
                Some(OkModelingCmdResponse::EntityLinearPatternTransform(resp)) => resp.entity_face_edge_ids.as_slice(),
                _ => &[],
            };
            return Ok(pattern_artifact_updates(
                artifacts,
                id,
                PatternSubType::Transform,
                ArtifactId::new(pattern_cmd.entity_id),
                face_edge_infos,
                code_ref,
            ));
        }
        ModelingCmd::EntityLinearPattern(pattern_cmd) => {
            let face_edge_infos = match response {
                Some(OkModelingCmdResponse::EntityLinearPattern(resp)) => resp.entity_face_edge_ids.as_slice(),
                _ => &[],
            };
            return Ok(pattern_artifact_updates(
                artifacts,
                id,
                PatternSubType::Linear,
                ArtifactId::new(pattern_cmd.entity_id),
                face_edge_infos,
                code_ref,
            ));
        }
        ModelingCmd::EntityCircularPattern(pattern_cmd) => {
            let face_edge_infos = match response {
                Some(OkModelingCmdResponse::EntityCircularPattern(resp)) => resp.entity_face_edge_ids.as_slice(),
                _ => &[],
            };
            return Ok(pattern_artifact_updates(
                artifacts,
                id,
                PatternSubType::Circular,
                ArtifactId::new(pattern_cmd.entity_id),
                face_edge_infos,
                code_ref,
            ));
        }
        ModelingCmd::EntityMirrorAcross(kcmc::EntityMirrorAcross {
            ids: original_solid_ids,
            ..
        }) => {
            let face_edge_infos = match response {
                Some(OkModelingCmdResponse::EntityMirrorAcross(resp)) => resp.entity_face_edge_ids.as_slice(),
                // A rejected modeling command has no response. Execution will
                // report the engine error; there is no mirrored artifact to add.
                None => return Ok(Vec::new()),
                Some(_) => internal_error!(
                    range,
                    "EntityMirrorAcross response variant not handled: id={id:?}, cmd={cmd:?}, response={response:?}"
                ),
            };
            return mirror_3d_artifact_updates(artifacts, original_solid_ids, face_edge_infos, code_ref, range, cmd);
        }
        ModelingCmd::EntityMirror(kcmc::EntityMirror {
            ids: original_path_ids, ..
        })
        | ModelingCmd::EntityMirrorAcrossEdge(kcmc::EntityMirrorAcrossEdge {
            ids: original_path_ids, ..
        }) => {
            let face_edge_infos = match response {
                Some(OkModelingCmdResponse::EntityMirror(resp)) => &resp.entity_face_edge_ids,
                Some(OkModelingCmdResponse::EntityMirrorAcrossEdge(resp)) => &resp.entity_face_edge_ids,
                _ => internal_error!(
                    range,
                    "Mirror response variant not handled: id={id:?}, cmd={cmd:?}, response={response:?}"
                ),
            };
            if original_path_ids.len() != face_edge_infos.len() {
                internal_error!(
                    range,
                    "EntityMirror or EntityMirrorAcrossEdge response has different number face edge info than original mirrored paths: id={id:?}, cmd={cmd:?}, response={response:?}"
                );
            }
            let mut return_arr = Vec::new();
            for (face_edge_info, original_path_id) in face_edge_infos.iter().zip(original_path_ids) {
                let original_path_id = ArtifactId::new(*original_path_id);
                let path_id = ArtifactId::new(face_edge_info.object_id);
                // The path may be an existing path that was extended or a new
                // path.
                let mut path = if let Some(Artifact::Path(path)) = artifacts.get(&path_id) {
                    // Existing path.
                    path.clone()
                } else {
                    // It's a new path.  We need the original path to get some
                    // of its info.
                    let Some(Artifact::Path(original_path)) = artifacts.get(&original_path_id) else {
                        // We couldn't find the original path. This is a bug.
                        internal_error!(
                            range,
                            "Couldn't find original path for mirror2d: original_path_id={original_path_id:?}, cmd={cmd:?}"
                        );
                    };
                    Path {
                        id: path_id,
                        sub_type: original_path.sub_type,
                        plane_id: original_path.plane_id,
                        seg_ids: Vec::new(),
                        sweep_id: None,
                        trajectory_sweep_id: None,
                        solid2d_id: None,
                        code_ref: code_ref.clone(),
                        composite_solid_id: None,
                        sketch_block_id: None,
                        origin_path_id: original_path.origin_path_id,
                        inner_path_id: None,
                        outer_path_id: None,
                        pattern_ids: Vec::new(),
                        consumed: false,
                    }
                };

                face_edge_info.edges.iter().for_each(|edge_id| {
                    let edge_id = ArtifactId::new(*edge_id);
                    return_arr.push(Artifact::Segment(Segment {
                        id: edge_id,
                        path_id: path.id,
                        source_segment_id: None,
                        original_seg_id: None,
                        surface_id: None,
                        edge_ids: Vec::new(),
                        edge_cut_id: None,
                        code_ref: code_ref.clone(),
                        common_surface_ids: Vec::new(),
                    }));
                    // Add the edge ID to the path.
                    path.seg_ids.push(edge_id);
                });

                return_arr.push(Artifact::Path(path));
            }
            return Ok(return_arr);
        }
        ModelingCmd::EntityClone(kcmc::EntityClone { entity_id, .. }) => {
            let source_entity_id = ArtifactId::new(*entity_id);
            let entity_clone_info = artifact_command.entity_clone_info;
            let source_id = entity_clone_info
                .map(|info| info.source_artifact_id)
                .unwrap_or(source_entity_id);
            let result_id = entity_clone_info.map(|info| info.result_artifact_id).unwrap_or(id);

            // Only solid clones provide this extra body identity. Without
            // this gate, cloning a lazy 2D pattern copy can resolve through
            // its source Path to a Sweep and fabricate a body artifact.
            let pattern_source_body_id = if entity_clone_info.is_some() && !artifacts.contains_key(&source_id) {
                pattern_source_body_id_for_copy(artifacts, source_id)
            } else {
                None
            };
            let source_artifact_id = pattern_source_body_id.unwrap_or(source_id);
            let Some(source_artifact) = artifacts.get(&source_artifact_id) else {
                return Ok(Vec::new());
            };

            let mut entity_id_map = entity_clone_id_maps.get(&uuid).cloned().unwrap_or_default();
            entity_id_map.insert(source_entity_id, id);
            if let Some(info) = entity_clone_info {
                entity_id_map.insert(info.source_topology_id, id);
            }
            entity_id_map.insert(source_id, result_id);
            entity_id_map.insert(source_artifact_id, result_id);
            if matches!(source_artifact, Artifact::CompositeSolid(_)) {
                add_composite_sweep_clone_id_mappings(artifacts, artifact_command.cmd_id, &mut entity_id_map);
            }

            let mut cloned_artifacts = Vec::new();
            cloned_artifacts.push(remap_artifact_for_clone(
                source_artifact,
                &entity_id_map,
                &code_ref,
                artifact_command.cmd_id,
                source_artifact_id,
            ));

            for artifact in artifacts.values() {
                let artifact_id = artifact.id();
                if artifact_id == source_artifact_id || !entity_id_map.contains_key(&artifact_id) {
                    continue;
                }
                cloned_artifacts.push(remap_artifact_for_clone(
                    artifact,
                    &entity_id_map,
                    &code_ref,
                    artifact_command.cmd_id,
                    source_artifact_id,
                ));
            }

            return Ok(cloned_artifacts);
        }
        ModelingCmd::Extrude(_)
        | ModelingCmd::TwistExtrude(_)
        | ModelingCmd::Revolve(_)
        | ModelingCmd::RevolveAboutEdge(_)
        | ModelingCmd::ExtrudeToReference(_) => {
            let target = match cmd {
                ModelingCmd::Extrude(kcmc::Extrude {
                    target: Some(target), ..
                }) => cmd_id_ref_to_artifact_id(target),
                ModelingCmd::Extrude(kcmc::Extrude {
                    target: None,
                    target_reference: Some(_),
                    ..
                }) => return Ok(Vec::new()),
                ModelingCmd::Extrude(kcmc::Extrude { target: None, .. }) => return Ok(Vec::new()),
                ModelingCmd::TwistExtrude(kcmc::TwistExtrude { target, .. })
                | ModelingCmd::Revolve(kcmc::Revolve { target, .. })
                | ModelingCmd::RevolveAboutEdge(kcmc::RevolveAboutEdge { target, .. }) => {
                    cmd_id_ref_to_artifact_id(target)
                }
                ModelingCmd::ExtrudeToReference(kcmc::ExtrudeToReference {
                    target: Some(target), ..
                }) => cmd_id_ref_to_artifact_id(target),
                ModelingCmd::ExtrudeToReference(kcmc::ExtrudeToReference { target: None, .. }) => {
                    return Ok(Vec::new());
                }
                _ => internal_error!(range, "Sweep-like command variant not handled: id={id:?}, cmd={cmd:?}"),
            };
            // Determine the resulting method from the specific command, if provided
            let method = match cmd {
                ModelingCmd::Extrude(kcmc::Extrude { extrude_method, .. }) => *extrude_method,
                ModelingCmd::ExtrudeToReference(kcmc::ExtrudeToReference { extrude_method, .. }) => *extrude_method,
                // TwistExtrude and Sweep don't carry method in the command; treat as Merge
                ModelingCmd::TwistExtrude(_) | ModelingCmd::Sweep(_) => {
                    kittycad_modeling_cmds::shared::ExtrudeMethod::Merge
                }
                // Revolve variants behave like New bodies in std layer
                ModelingCmd::Revolve(_) | ModelingCmd::RevolveAboutEdge(_) => {
                    kittycad_modeling_cmds::shared::ExtrudeMethod::New
                }
                _ => kittycad_modeling_cmds::shared::ExtrudeMethod::Merge,
            };
            let method = artifact_sweep_method(method);
            let sub_type = match cmd {
                ModelingCmd::Extrude(_) => SweepSubType::Extrusion,
                ModelingCmd::ExtrudeToReference(_) => SweepSubType::Extrusion,
                ModelingCmd::TwistExtrude(_) => SweepSubType::ExtrusionTwist,
                ModelingCmd::Revolve(_) => SweepSubType::Revolve,
                ModelingCmd::RevolveAboutEdge(_) => SweepSubType::RevolveAboutEdge,
                _ => internal_error!(range, "Sweep-like command variant not handled: id={id:?}, cmd={cmd:?}",),
            };
            let mut return_arr = Vec::new();
            return_arr.push(Artifact::Sweep(Sweep {
                id,
                sub_type,
                path_id: target,
                surface_ids: Vec::new(),
                edge_ids: Vec::new(),
                code_ref,
                source_sweep_id: None,
                trajectory_id: None,
                method,
                consumed: false,
                pattern_ids: Vec::new(),
            }));
            let path = artifacts.get(&target);
            if let Some(Artifact::Path(path)) = path {
                let mut new_path = path.clone();
                new_path.sweep_id = Some(id);
                new_path.consumed = true;
                return_arr.push(Artifact::Path(new_path));
                if let Some(inner_path_id) = path.inner_path_id
                    && let Some(inner_path_artifact) = artifacts.get(&inner_path_id)
                    && let Artifact::Path(mut inner_path_artifact) = inner_path_artifact.clone()
                {
                    inner_path_artifact.sweep_id = Some(id);
                    inner_path_artifact.consumed = true;
                    return_arr.push(Artifact::Path(inner_path_artifact))
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Sweep(kcmc::Sweep { target, trajectory, .. }) => {
            // Determine the resulting method from the specific command, if provided
            let method = ArtifactSweepMethod::Merge;
            let sub_type = SweepSubType::Sweep;
            let mut return_arr = Vec::new();
            let target = cmd_id_ref_to_artifact_id(target);
            let trajectory = cmd_id_ref_to_artifact_id(trajectory);
            return_arr.push(Artifact::Sweep(Sweep {
                id,
                sub_type,
                path_id: target,
                surface_ids: Vec::new(),
                edge_ids: Vec::new(),
                code_ref,
                source_sweep_id: None,
                trajectory_id: Some(trajectory),
                method,
                consumed: false,
                pattern_ids: Vec::new(),
            }));
            let path = artifacts.get(&target);
            if let Some(Artifact::Path(path)) = path {
                let mut new_path = path.clone();
                new_path.sweep_id = Some(id);
                new_path.consumed = true;
                return_arr.push(Artifact::Path(new_path));
                if let Some(inner_path_id) = path.inner_path_id
                    && let Some(inner_path_artifact) = artifacts.get(&inner_path_id)
                    && let Artifact::Path(mut inner_path_artifact) = inner_path_artifact.clone()
                {
                    inner_path_artifact.sweep_id = Some(id);
                    inner_path_artifact.consumed = true;
                    return_arr.push(Artifact::Path(inner_path_artifact))
                }
            }
            if let Some(trajectory_artifact) = artifacts.get(&trajectory) {
                match trajectory_artifact {
                    Artifact::Path(path) => {
                        let mut new_path = path.clone();
                        new_path.trajectory_sweep_id = Some(id);
                        new_path.consumed = true;
                        return_arr.push(Artifact::Path(new_path));
                    }
                    Artifact::Helix(helix) => {
                        let mut new_helix = helix.clone();
                        new_helix.trajectory_sweep_id = Some(id);
                        new_helix.consumed = true;
                        return_arr.push(Artifact::Helix(new_helix));
                    }
                    _ => {}
                }
            };
            return Ok(return_arr);
        }
        ModelingCmd::SurfaceBlend(surface_blend_cmd) => {
            let surface_id_to_path_id = |surface_id: ArtifactId| -> Option<ArtifactId> {
                match artifacts.get(&surface_id) {
                    Some(Artifact::Path(path)) => Some(path.id),
                    Some(Artifact::Segment(segment)) => Some(segment.path_id),
                    Some(Artifact::Sweep(sweep)) => Some(sweep.path_id),
                    Some(Artifact::Wall(wall)) => artifacts.get(&wall.sweep_id).and_then(|artifact| match artifact {
                        Artifact::Sweep(sweep) => Some(sweep.path_id),
                        _ => None,
                    }),
                    Some(Artifact::Cap(cap)) => artifacts.get(&cap.sweep_id).and_then(|artifact| match artifact {
                        Artifact::Sweep(sweep) => Some(sweep.path_id),
                        _ => None,
                    }),
                    _ => None,
                }
            };
            let Some(first_surface_ref) = surface_blend_cmd.surfaces.first() else {
                internal_error!(range, "SurfaceBlend command has no surfaces: id={id:?}, cmd={cmd:?}");
            };
            let first_surface_id = ArtifactId::new(first_surface_ref.object_id);
            let path_id = surface_id_to_path_id(first_surface_id).unwrap_or(first_surface_id);
            let trajectory_id = surface_blend_cmd
                .surfaces
                .get(1)
                .map(|surface| ArtifactId::new(surface.object_id))
                .and_then(surface_id_to_path_id);
            let return_arr = vec![Artifact::Sweep(Sweep {
                id,
                sub_type: SweepSubType::Blend,
                path_id,
                surface_ids: Vec::new(),
                edge_ids: Vec::new(),
                code_ref,
                source_sweep_id: None,
                trajectory_id,
                method: ArtifactSweepMethod::New,
                consumed: false,
                pattern_ids: Vec::new(),
            })];
            return Ok(return_arr);
        }
        ModelingCmd::Loft(loft_cmd) => {
            let Some(OkModelingCmdResponse::Loft(_)) = response else {
                return Ok(Vec::new());
            };
            let mut return_arr = Vec::new();
            return_arr.push(Artifact::Sweep(Sweep {
                id,
                sub_type: SweepSubType::Loft,
                // TODO: Using the first one.  Make sure to revisit this
                // choice, don't think it matters for now.
                path_id: ArtifactId::new(*loft_cmd.section_ids.first().ok_or_else(|| {
                    KclError::new_internal(KclErrorDetails::new(
                        format!("Expected at least one section ID in Loft command: {id:?}; cmd={cmd:?}"),
                        vec![range],
                    ))
                })?),
                surface_ids: Vec::new(),
                edge_ids: Vec::new(),
                code_ref,
                source_sweep_id: None,
                trajectory_id: None,
                method: ArtifactSweepMethod::Merge,
                consumed: false,
                pattern_ids: Vec::new(),
            }));
            for section_id in &loft_cmd.section_ids {
                let path = artifacts.get(&ArtifactId::new(*section_id));
                if let Some(Artifact::Path(path)) = path {
                    let mut new_path = path.clone();
                    new_path.consumed = true;
                    new_path.sweep_id = Some(id);
                    return_arr.push(Artifact::Path(new_path));
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dGetExtrusionFaceInfo(_) => {
            let Some(OkModelingCmdResponse::Solid3dGetExtrusionFaceInfo(face_info)) = response else {
                return Ok(Vec::new());
            };
            let mut return_arr = Vec::new();
            let mut last_path = None;
            for face in &face_info.faces {
                if face.cap != ExtrusionFaceCapType::None {
                    continue;
                }
                let Some(curve_id) = face.curve_id.map(ArtifactId::new) else {
                    continue;
                };
                let Some(face_id) = face.face_id.map(ArtifactId::new) else {
                    continue;
                };
                let Some(Artifact::Segment(seg)) = artifacts.get(&curve_id) else {
                    continue;
                };
                let Some(Artifact::Path(path)) = artifacts.get(&seg.path_id) else {
                    continue;
                };
                last_path = Some(path);
                let Some(path_sweep_id) = path.sweep_id else {
                    // If the path doesn't have a sweep ID, check if it's a
                    // hole.
                    if path.outer_path_id.is_some() {
                        continue; // hole not handled
                    }
                    return Err(KclError::new_internal(KclErrorDetails::new(
                        format!(
                            "Expected a sweep ID on the path when processing Solid3dGetExtrusionFaceInfo command, but we have none:\n{id:#?}\n{path:#?}"
                        ),
                        vec![range],
                    )));
                };
                let extra_artifact = exec_artifacts.values().find(|a| {
                    if let Artifact::StartSketchOnFace(s) = a {
                        s.face_id == face_id
                    } else if let Artifact::StartSketchOnPlane(s) = a {
                        s.plane_id == face_id
                    } else {
                        false
                    }
                });
                let sketch_on_face_code_ref = extra_artifact
                    .and_then(|a| match a {
                        Artifact::StartSketchOnFace(s) => Some(s.code_ref.clone()),
                        Artifact::StartSketchOnPlane(s) => Some(s.code_ref.clone()),
                        _ => None,
                    })
                    // TODO: If we didn't find it, it's probably a bug.
                    .unwrap_or_default();

                return_arr.push(Artifact::Wall(Wall {
                    id: face_id,
                    seg_id: curve_id,
                    edge_cut_edge_ids: Vec::new(),
                    sweep_id: path_sweep_id,
                    path_ids: Vec::new(),
                    face_code_ref: sketch_on_face_code_ref,
                    cmd_id: artifact_command.cmd_id,
                }));
                let mut new_seg = seg.clone();
                new_seg.surface_id = Some(face_id);
                return_arr.push(Artifact::Segment(new_seg));
                if let Some(Artifact::Sweep(sweep)) = path.sweep_id.and_then(|id| artifacts.get(&id)) {
                    let mut new_sweep = sweep.clone();
                    new_sweep.surface_ids = vec![face_id];
                    return_arr.push(Artifact::Sweep(new_sweep));
                }
            }
            if let Some(path) = last_path {
                for face in &face_info.faces {
                    let sub_type = match face.cap {
                        ExtrusionFaceCapType::Top => CapSubType::End,
                        ExtrusionFaceCapType::Bottom => CapSubType::Start,
                        ExtrusionFaceCapType::None | ExtrusionFaceCapType::Both => continue,
                        _other => {
                            // Modeling API has added something we're not aware of.
                            continue;
                        }
                    };
                    let Some(face_id) = face.face_id.map(ArtifactId::new) else {
                        continue;
                    };
                    let Some(path_sweep_id) = path.sweep_id else {
                        // If the path doesn't have a sweep ID, check if it's a
                        // hole.
                        if path.outer_path_id.is_some() {
                            continue; // hole not handled
                        }
                        return Err(KclError::new_internal(KclErrorDetails::new(
                            format!(
                                "Expected a sweep ID on the path when processing last path's Solid3dGetExtrusionFaceInfo command, but we have none:\n{id:#?}\n{path:#?}"
                            ),
                            vec![range],
                        )));
                    };
                    let extra_artifact = exec_artifacts.values().find(|a| {
                        if let Artifact::StartSketchOnFace(s) = a {
                            s.face_id == face_id
                        } else if let Artifact::StartSketchOnPlane(s) = a {
                            s.plane_id == face_id
                        } else {
                            false
                        }
                    });
                    let sketch_on_face_code_ref = extra_artifact
                        .and_then(|a| match a {
                            Artifact::StartSketchOnFace(s) => Some(s.code_ref.clone()),
                            Artifact::StartSketchOnPlane(s) => Some(s.code_ref.clone()),
                            _ => None,
                        })
                        // TODO: If we didn't find it, it's probably a bug.
                        .unwrap_or_default();
                    return_arr.push(Artifact::Cap(Cap {
                        id: face_id,
                        sub_type,
                        edge_cut_edge_ids: Vec::new(),
                        sweep_id: path_sweep_id,
                        path_ids: Vec::new(),
                        face_code_ref: sketch_on_face_code_ref,
                        cmd_id: artifact_command.cmd_id,
                    }));
                    let Some(Artifact::Sweep(sweep)) = artifacts.get(&path_sweep_id) else {
                        continue;
                    };
                    let mut new_sweep = sweep.clone();
                    new_sweep.surface_ids = vec![face_id];
                    return_arr.push(Artifact::Sweep(new_sweep));
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dGetAdjacencyInfo(kcmc::Solid3dGetAdjacencyInfo { .. }) => {
            let Some(OkModelingCmdResponse::Solid3dGetAdjacencyInfo(info)) = response else {
                return Ok(Vec::new());
            };

            let mut return_arr = Vec::new();
            let adjacent_edge_ids = info
                .edges
                .iter()
                .filter_map(|edge| edge.adjacent_info.as_ref().map(|info| info.edge_id))
                .collect::<AHashSet<_>>();
            for (index, edge) in info.edges.iter().enumerate() {
                let Some(original_info) = &edge.original_info else {
                    continue;
                };
                let edge_id = ArtifactId::new(original_info.edge_id);
                let Some(artifact) = artifacts.get(&edge_id) else {
                    continue;
                };
                match artifact {
                    Artifact::Segment(segment) => {
                        let mut new_segment = segment.clone();
                        new_segment.common_surface_ids =
                            original_info.faces.iter().map(|face| ArtifactId::new(*face)).collect();
                        return_arr.push(Artifact::Segment(new_segment));
                    }
                    Artifact::SweepEdge(sweep_edge) => {
                        let mut new_sweep_edge = sweep_edge.clone();
                        new_sweep_edge.common_surface_ids =
                            original_info.faces.iter().map(|face| ArtifactId::new(*face)).collect();
                        return_arr.push(Artifact::SweepEdge(new_sweep_edge));
                    }
                    _ => {}
                };

                let Some(Artifact::Segment(segment)) = artifacts.get(&edge_id) else {
                    continue;
                };
                let Some(surface_id) = segment.surface_id else {
                    continue;
                };
                let Some(Artifact::Wall(wall)) = artifacts.get(&surface_id) else {
                    continue;
                };
                let Some(Artifact::Sweep(sweep)) = artifacts.get(&wall.sweep_id) else {
                    continue;
                };
                let Some(Artifact::Path(_)) = artifacts.get(&sweep.path_id) else {
                    continue;
                };

                if let Some(opposite_info) = &edge.opposite_info {
                    return_arr.push(Artifact::SweepEdge(SweepEdge {
                        id: opposite_info.edge_id.into(),
                        sub_type: SweepEdgeSubType::Opposite,
                        seg_id: edge_id,
                        cmd_id: artifact_command.cmd_id,
                        index,
                        sweep_id: sweep.id,
                        common_surface_ids: opposite_info.faces.iter().map(|face| ArtifactId::new(*face)).collect(),
                    }));
                    let mut new_segment = segment.clone();
                    new_segment.edge_ids = vec![opposite_info.edge_id.into()];
                    return_arr.push(Artifact::Segment(new_segment));
                    let mut new_sweep = sweep.clone();
                    new_sweep.edge_ids = vec![opposite_info.edge_id.into()];
                    return_arr.push(Artifact::Sweep(new_sweep));
                    let mut new_wall = wall.clone();
                    new_wall.edge_cut_edge_ids = vec![opposite_info.edge_id.into()];
                    return_arr.push(Artifact::Wall(new_wall));
                }
                if let Some(adjacent_info) = &edge.adjacent_info {
                    return_arr.push(Artifact::SweepEdge(SweepEdge {
                        id: adjacent_info.edge_id.into(),
                        sub_type: SweepEdgeSubType::Adjacent,
                        seg_id: edge_id,
                        cmd_id: artifact_command.cmd_id,
                        index,
                        sweep_id: sweep.id,
                        common_surface_ids: adjacent_info.faces.iter().map(|face| ArtifactId::new(*face)).collect(),
                    }));
                    let mut new_segment = segment.clone();
                    new_segment.edge_ids = vec![adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Segment(new_segment));
                    let mut new_sweep = sweep.clone();
                    new_sweep.edge_ids = vec![adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Sweep(new_sweep));
                    let mut new_wall = wall.clone();
                    new_wall.edge_cut_edge_ids = vec![adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Wall(new_wall));
                }
                // Internal edges are already represented as the next adjacent edge of
                // the preceding segment. Only add the open component's start edge.
                if let Some(previous_adjacent_info) = &edge.previous_adjacent_info
                    && !adjacent_edge_ids.contains(&previous_adjacent_info.edge_id)
                {
                    return_arr.push(Artifact::SweepEdge(SweepEdge {
                        id: previous_adjacent_info.edge_id.into(),
                        sub_type: SweepEdgeSubType::PreviousAdjacent,
                        seg_id: edge_id,
                        cmd_id: artifact_command.cmd_id,
                        index,
                        sweep_id: sweep.id,
                        common_surface_ids: previous_adjacent_info
                            .faces
                            .iter()
                            .map(|face| ArtifactId::new(*face))
                            .collect(),
                    }));
                    let mut new_segment = segment.clone();
                    new_segment.edge_ids = vec![previous_adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Segment(new_segment));
                    let mut new_sweep = sweep.clone();
                    new_sweep.edge_ids = vec![previous_adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Sweep(new_sweep));
                    let mut new_wall = wall.clone();
                    new_wall.edge_cut_edge_ids = vec![previous_adjacent_info.edge_id.into()];
                    return_arr.push(Artifact::Wall(new_wall));
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dMultiJoin(cmd) => {
            let mut return_arr = Vec::new();
            return_arr.push(Artifact::CompositeSolid(CompositeSolid {
                id,
                consumed: false,
                sub_type: CompositeSolidSubType::Union,
                output_index: None,
                solid_ids: cmd.object_ids.iter().map(|id| id.into()).collect(),
                tool_ids: vec![],
                code_ref,
                composite_solid_id: None,
                pattern_ids: Vec::new(),
            }));

            let solid_ids = cmd.object_ids.iter().copied().map(ArtifactId::new).collect::<Vec<_>>();

            for input_id in &solid_ids {
                if let Some(artifact) = artifacts.get(input_id)
                    && let Artifact::CompositeSolid(comp) = artifact
                {
                    let mut new_comp = comp.clone();
                    new_comp.composite_solid_id = Some(id);
                    new_comp.consumed = true;
                    return_arr.push(Artifact::CompositeSolid(new_comp));
                } else if let Some(Artifact::Sweep(sweep)) = artifacts.get(input_id) {
                    let mut new_sweep = sweep.clone();
                    new_sweep.consumed = true;
                    return_arr.push(Artifact::Sweep(new_sweep));
                }
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dFilletEdge(cmd) => {
            let mut return_arr = Vec::new();
            let edge_id = if let Some(edge_id) = cmd.edge_id {
                ArtifactId::new(edge_id)
            } else {
                let Some(edge_id) = cmd.edge_ids.first() else {
                    internal_error!(
                        range,
                        "Solid3dFilletEdge command has no edge ID: id={id:?}, cmd={cmd:?}"
                    );
                };
                edge_id.into()
            };
            return_arr.push(Artifact::EdgeCut(EdgeCut {
                id,
                sub_type: edge_cut_sub_type(cmd.cut_type),
                consumed_edge_id: edge_id,
                edge_ids: Vec::new(),
                surface_id: None,
                code_ref,
            }));
            let consumed_edge = artifacts.get(&edge_id);
            if let Some(Artifact::Segment(consumed_edge)) = consumed_edge {
                let mut new_segment = consumed_edge.clone();
                new_segment.edge_cut_id = Some(id);
                return_arr.push(Artifact::Segment(new_segment));
            } else {
                // TODO: Handle other types like SweepEdge.
            }
            return Ok(return_arr);
        }
        ModelingCmd::Solid3dCutEdges(cmd) => {
            let mut return_arr = Vec::new();
            let edge_id = if let Some(edge_id) = cmd.edge_ids.first() {
                edge_id.into()
            } else {
                internal_error!(range, "Solid3dCutEdges command has no edge ID: id={id:?}, cmd={cmd:?}");
            };
            return_arr.push(Artifact::EdgeCut(EdgeCut {
                id,
                sub_type: edge_cut_sub_type_v2(cmd.cut_type),
                consumed_edge_id: edge_id,
                edge_ids: Vec::new(),
                surface_id: None,
                code_ref,
            }));
            let consumed_edge = artifacts.get(&edge_id);
            if let Some(Artifact::Segment(consumed_edge)) = consumed_edge {
                let mut new_segment = consumed_edge.clone();
                new_segment.edge_cut_id = Some(id);
                return_arr.push(Artifact::Segment(new_segment));
            } else {
                // TODO: Handle other types like SweepEdge.
            }
            return Ok(return_arr);
        }
        ModelingCmd::EntityMakeHelix(cmd) => {
            let cylinder_id = ArtifactId::new(cmd.cylinder_id);
            let return_arr = vec![Artifact::Helix(Helix {
                id,
                axis_id: Some(cylinder_id),
                code_ref,
                trajectory_sweep_id: None,
                consumed: false,
            })];
            return Ok(return_arr);
        }
        ModelingCmd::EntityMakeHelixFromParams(_) => {
            let return_arr = vec![Artifact::Helix(Helix {
                id,
                axis_id: None,
                code_ref,
                trajectory_sweep_id: None,
                consumed: false,
            })];
            return Ok(return_arr);
        }
        ModelingCmd::EntityMakeHelixFromEdge(helix) => {
            let return_arr = vec![Artifact::Helix(Helix {
                id,
                axis_id: helix.edge_id.map(ArtifactId::new),
                code_ref,
                trajectory_sweep_id: None,
                consumed: false,
            })];
            // We could add the reverse graph edge connecting from the edge to
            // the helix here, but it's not useful right now.
            return Ok(return_arr);
        }
        ModelingCmd::Solid2dAddHole(solid2d_add_hole) => {
            let mut return_arr = Vec::new();
            // Add the hole to the outer.
            let outer_path = artifacts.get(&ArtifactId::new(solid2d_add_hole.object_id));
            if let Some(Artifact::Path(path)) = outer_path {
                let mut new_path = path.clone();
                new_path.inner_path_id = Some(ArtifactId::new(solid2d_add_hole.hole_id));
                return_arr.push(Artifact::Path(new_path));
            }
            // Add the outer to the hole.
            let inner_solid2d = artifacts.get(&ArtifactId::new(solid2d_add_hole.hole_id));
            if let Some(Artifact::Path(path)) = inner_solid2d {
                let mut new_path = path.clone();
                new_path.consumed = true;
                new_path.outer_path_id = Some(ArtifactId::new(solid2d_add_hole.object_id));
                return_arr.push(Artifact::Path(new_path));
            }
            return Ok(return_arr);
        }
        ModelingCmd::BooleanIntersection(_) | ModelingCmd::BooleanSubtract(_) | ModelingCmd::BooleanUnion(_) => {
            let (sub_type, solid_ids, tool_ids) = match cmd {
                ModelingCmd::BooleanIntersection(intersection) => {
                    let solid_ids = intersection
                        .solid_ids
                        .iter()
                        .copied()
                        .map(ArtifactId::new)
                        .collect::<Vec<_>>();
                    (CompositeSolidSubType::Intersect, solid_ids, Vec::new())
                }
                ModelingCmd::BooleanSubtract(subtract) => {
                    let solid_ids = subtract
                        .target_ids
                        .iter()
                        .copied()
                        .map(ArtifactId::new)
                        .collect::<Vec<_>>();
                    let tool_ids = subtract
                        .tool_ids
                        .iter()
                        .copied()
                        .map(ArtifactId::new)
                        .collect::<Vec<_>>();
                    (CompositeSolidSubType::Subtract, solid_ids, tool_ids)
                }
                ModelingCmd::BooleanUnion(union) => {
                    let solid_ids = union.solid_ids.iter().copied().map(ArtifactId::new).collect::<Vec<_>>();
                    (CompositeSolidSubType::Union, solid_ids, Vec::new())
                }
                _ => internal_error!(
                    range,
                    "Boolean or composite command variant not handled: id={id:?}, cmd={cmd:?}"
                ),
            };

            let mut new_solid_ids = vec![id];

            // Make sure we don't ever create a duplicate ID since merge_ids
            // can't handle it.
            let not_cmd_id = move |solid_id: &ArtifactId| *solid_id != id;

            match (cmd, response) {
                (
                    ModelingCmd::BooleanSubtract(subtract_cmd),
                    Some(OkModelingCmdResponse::BooleanSubtract(subtract_resp)),
                ) => {
                    new_solid_ids = boolean_subtract_output_artifact_ids(
                        id,
                        &subtract_cmd.target_ids,
                        &subtract_cmd.tool_ids,
                        &subtract_resp.extra_solid_ids,
                    );
                }
                (_, Some(OkModelingCmdResponse::BooleanIntersection(intersection))) => intersection
                    .extra_solid_ids
                    .iter()
                    .copied()
                    .map(ArtifactId::new)
                    .filter(not_cmd_id)
                    .for_each(|id| new_solid_ids.push(id)),
                (_, Some(OkModelingCmdResponse::BooleanUnion(union))) => union
                    .extra_solid_ids
                    .iter()
                    .copied()
                    .map(ArtifactId::new)
                    .filter(not_cmd_id)
                    .for_each(|id| new_solid_ids.push(id)),
                _ => {}
            }

            let mut return_arr = Vec::new();
            let mut consumed_sweep_ids = AHashSet::default();
            let mut input_ids = solid_ids.clone();
            merge_ids(&mut input_ids, tool_ids.clone());

            if new_solid_ids.is_empty() {
                update_csg_input_artifacts(&mut return_arr, artifacts, &input_ids, None, &mut consumed_sweep_ids);
            }

            // Create the new composite solids and update their linked artifacts
            for solid_id in &new_solid_ids {
                // Create the composite solid
                return_arr.push(Artifact::CompositeSolid(CompositeSolid {
                    id: *solid_id,
                    consumed: false,
                    sub_type,
                    output_index: None,
                    solid_ids: solid_ids.clone(),
                    tool_ids: tool_ids.clone(),
                    code_ref: code_ref.clone(),
                    composite_solid_id: None,
                    pattern_ids: Vec::new(),
                }));

                update_csg_input_artifacts(
                    &mut return_arr,
                    artifacts,
                    &input_ids,
                    Some(*solid_id),
                    &mut consumed_sweep_ids,
                );
            }

            return Ok(return_arr);
        }
        ModelingCmd::BooleanImprint(imprint) => {
            let solid_ids = imprint
                .body_ids
                .iter()
                .copied()
                .map(ArtifactId::new)
                .collect::<Vec<_>>();
            let tool_ids = imprint
                .tool_ids
                .as_ref()
                .map(|ids| ids.iter().copied().map(ArtifactId::new).collect::<Vec<_>>())
                .unwrap_or_default();

            let mut new_solid_ids = vec![id];
            let not_cmd_id = move |solid_id: &ArtifactId| *solid_id != id;
            if let Some(OkModelingCmdResponse::BooleanImprint(imprint)) = response {
                imprint
                    .extra_solid_ids
                    .iter()
                    .copied()
                    .map(ArtifactId::new)
                    .filter(not_cmd_id)
                    .for_each(|id| new_solid_ids.push(id));
            }

            let mut return_arr = Vec::new();
            let mut consumed_sweep_ids = AHashSet::default();

            for input_id in solid_ids.iter().chain(tool_ids.iter()) {
                let sweep_id = match artifacts.get(input_id) {
                    Some(Artifact::Sweep(sweep)) => Some(sweep.id),
                    Some(Artifact::Path(path)) => path.sweep_id,
                    _ => None,
                };

                if let Some(sweep_id) = sweep_id
                    && consumed_sweep_ids.insert(sweep_id)
                    && let Some(Artifact::Sweep(sweep)) = artifacts.get(&sweep_id)
                {
                    let mut new_sweep = sweep.clone();
                    new_sweep.consumed = true;
                    return_arr.push(Artifact::Sweep(new_sweep));
                }
            }

            for (output_index, solid_id) in new_solid_ids.iter().enumerate() {
                return_arr.push(Artifact::CompositeSolid(CompositeSolid {
                    id: *solid_id,
                    consumed: false,
                    sub_type: CompositeSolidSubType::Split,
                    output_index: Some(output_index),
                    solid_ids: solid_ids.clone(),
                    tool_ids: tool_ids.clone(),
                    code_ref: code_ref.clone(),
                    composite_solid_id: None,
                    pattern_ids: Vec::new(),
                }));

                for input_id in solid_ids.iter().chain(tool_ids.iter()) {
                    if let Some(artifact) = artifacts.get(input_id) {
                        match artifact {
                            Artifact::CompositeSolid(comp) => {
                                let mut new_comp = comp.clone();
                                new_comp.composite_solid_id = Some(*solid_id);
                                new_comp.consumed = true;
                                return_arr.push(Artifact::CompositeSolid(new_comp));
                            }
                            Artifact::Path(path) => {
                                let mut new_path = path.clone();
                                new_path.composite_solid_id = Some(*solid_id);

                                return_arr.push(Artifact::Path(new_path));
                            }
                            _ => {}
                        }
                    }
                }
            }

            return Ok(return_arr);
        }
        _ => {}
    }

    Ok(Vec::new())
}