Track artifact commands and operations per-module (#7426)

* Change so that operations are stored per module

* Refactor so that all modeling commands go through ExecState

* Remove unneeded PartialOrd implementations

* Remove artifact_commands from KclError since it was only for debugging

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

rust/kcl-lib/e2e/executor/cache.rs

@@ -300,12 +300,6 @@ extrude001 = extrude(profile001, length = 4)
     let first = &result.first().unwrap().2;
     let second = &result.last().unwrap().2;
 
-    assert!(
-        first.artifact_commands.len() < second.artifact_commands.len(),
-        "Second should have all the artifact commands of the first, plus more. first={:?}, second={:?}",
-        first.artifact_commands.len(),
-        second.artifact_commands.len()
-    );
     assert!(
         first.artifact_graph.len() < second.artifact_graph.len(),
         "Second should have all the artifacts of the first, plus more. first={:?}, second={:?}",

rust/kcl-lib/src/errors.rs

@@ -135,8 +135,10 @@ pub struct KclErrorWithOutputs {
     pub non_fatal: Vec<CompilationError>,
     #[cfg(feature = "artifact-graph")]
     pub operations: Vec<Operation>,
+    // TODO: Remove this field.  Doing so breaks the ts-rs output for some
+    // reason.
     #[cfg(feature = "artifact-graph")]
-    pub artifact_commands: Vec<ArtifactCommand>,
+    pub _artifact_commands: Vec<ArtifactCommand>,
     #[cfg(feature = "artifact-graph")]
     pub artifact_graph: ArtifactGraph,
     pub filenames: IndexMap<ModuleId, ModulePath>,
@@ -162,7 +164,7 @@ impl KclErrorWithOutputs {
             #[cfg(feature = "artifact-graph")]
             operations,
             #[cfg(feature = "artifact-graph")]
-            artifact_commands,
+            _artifact_commands: artifact_commands,
             #[cfg(feature = "artifact-graph")]
             artifact_graph,
             filenames,
@@ -177,7 +179,7 @@ impl KclErrorWithOutputs {
             #[cfg(feature = "artifact-graph")]
             operations: Default::default(),
             #[cfg(feature = "artifact-graph")]
-            artifact_commands: Default::default(),
+            _artifact_commands: Default::default(),
             #[cfg(feature = "artifact-graph")]
             artifact_graph: Default::default(),
             filenames: Default::default(),

rust/kcl-lib/src/execution/artifact.rs

@@ -45,26 +45,6 @@ pub struct ArtifactCommand {
     pub command: ModelingCmd,
 }
 
-impl PartialOrd for ArtifactCommand {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        // Order by the source range.
-        let range = self.range.cmp(&other.range);
-        if range != std::cmp::Ordering::Equal {
-            return Some(range);
-        }
-        #[cfg(test)]
-        {
-            // If the ranges are equal, order by the serde variant.
-            Some(
-                crate::variant_name::variant_name(&self.command)
-                    .cmp(&crate::variant_name::variant_name(&other.command)),
-            )
-        }
-        #[cfg(not(test))]
-        self.cmd_id.partial_cmp(&other.cmd_id)
-    }
-}
-
 pub type DummyPathToNode = Vec<()>;
 
 fn serialize_dummy_path_to_node<S>(_path_to_node: &DummyPathToNode, serializer: S) -> Result<S::Ok, S::Error>

rust/kcl-lib/src/execution/cache.rs

@@ -111,8 +111,6 @@ impl GlobalState {
             #[cfg(feature = "artifact-graph")]
             operations: self.exec_state.artifacts.operations,
             #[cfg(feature = "artifact-graph")]
-            artifact_commands: self.exec_state.artifacts.commands,
-            #[cfg(feature = "artifact-graph")]
             artifact_graph: self.exec_state.artifacts.graph,
             errors: self.exec_state.errors,
             default_planes: ctx.engine.get_default_planes().read().await.clone(),

rust/kcl-lib/src/execution/cad_op.rs

@@ -2,6 +2,8 @@ use indexmap::IndexMap;
 use serde::Serialize;
 
 use super::{types::NumericType, ArtifactId, KclValue};
+#[cfg(feature = "artifact-graph")]
+use crate::parsing::ast::types::{Node, Program};
 use crate::{ModuleId, NodePath, SourceRange};
 
 /// A CAD modeling operation for display in the feature tree, AKA operations
@@ -37,26 +39,6 @@ pub enum Operation {
     GroupEnd,
 }
 
-/// A way for sorting the operations in the timeline.  This is used to sort
-/// operations in the timeline and to determine the order of operations.
-/// We use this for the multi-threaded snapshotting, so that we can have deterministic
-/// output.
-impl PartialOrd for Operation {
-    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        Some(match (self, other) {
-            (Self::StdLibCall { source_range: a, .. }, Self::StdLibCall { source_range: b, .. }) => a.cmp(b),
-            (Self::StdLibCall { source_range: a, .. }, Self::GroupBegin { source_range: b, .. }) => a.cmp(b),
-            (Self::StdLibCall { .. }, Self::GroupEnd) => std::cmp::Ordering::Less,
-            (Self::GroupBegin { source_range: a, .. }, Self::GroupBegin { source_range: b, .. }) => a.cmp(b),
-            (Self::GroupBegin { source_range: a, .. }, Self::StdLibCall { source_range: b, .. }) => a.cmp(b),
-            (Self::GroupBegin { .. }, Self::GroupEnd) => std::cmp::Ordering::Less,
-            (Self::GroupEnd, Self::StdLibCall { .. }) => std::cmp::Ordering::Greater,
-            (Self::GroupEnd, Self::GroupBegin { .. }) => std::cmp::Ordering::Greater,
-            (Self::GroupEnd, Self::GroupEnd) => std::cmp::Ordering::Equal,
-        })
-    }
-}
-
 impl Operation {
     /// If the variant is `StdLibCall`, set the `is_error` field.
     pub(crate) fn set_std_lib_call_is_error(&mut self, is_err: bool) {
@@ -65,6 +47,25 @@ impl Operation {
             Self::GroupBegin { .. } | Self::GroupEnd => {}
         }
     }
+
+    #[cfg(feature = "artifact-graph")]
+    pub(crate) fn fill_node_paths(&mut self, program: &Node<Program>, cached_body_items: usize) {
+        match self {
+            Operation::StdLibCall {
+                node_path,
+                source_range,
+                ..
+            }
+            | Operation::GroupBegin {
+                node_path,
+                source_range,
+                ..
+            } => {
+                node_path.fill_placeholder(program, cached_body_items, *source_range);
+            }
+            Operation::GroupEnd => {}
+        }
+    }
 }
 
 #[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]

rust/kcl-lib/src/execution/exec_ast.rs

@@ -11,8 +11,8 @@ use crate::{
         memory,
         state::ModuleState,
         types::{NumericType, PrimitiveType, RuntimeType},
-        BodyType, EnvironmentRef, ExecState, ExecutorContext, KclValue, Metadata, PlaneType, StatementKind,
-        TagIdentifier,
+        BodyType, EnvironmentRef, ExecState, ExecutorContext, KclValue, Metadata, ModelingCmdMeta, ModuleArtifactState,
+        PlaneType, StatementKind, TagIdentifier,
     },
     fmt,
     modules::{ModuleId, ModulePath, ModuleRepr},
@@ -83,7 +83,7 @@ impl ExecutorContext {
         preserve_mem: bool,
         module_id: ModuleId,
         path: &ModulePath,
-    ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>), KclError> {
+    ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>, ModuleArtifactState), KclError> {
         crate::log::log(format!("enter module {path} {}", exec_state.stack()));
 
         let mut local_state = ModuleState::new(path.clone(), exec_state.stack().memory.clone(), Some(module_id));
@@ -108,13 +108,16 @@ impl ExecutorContext {
         } else {
             exec_state.mut_stack().pop_env()
         };
-        if !preserve_mem {
+        let module_artifacts = if !preserve_mem {
             std::mem::swap(&mut exec_state.mod_local, &mut local_state);
-        }
+            local_state.artifacts
+        } else {
+            Default::default()
+        };
 
         crate::log::log(format!("leave {path}"));
 
-        result.map(|result| (result, env_ref, local_state.module_exports))
+        result.map(|result| (result, env_ref, local_state.module_exports, module_artifacts))
     }
 
     /// Execute an AST's program.
@@ -450,12 +453,12 @@ impl ExecutorContext {
 
         if matches!(body_type, BodyType::Root) {
             // Flush the batch queue.
-            self.engine
+            exec_state
                 .flush_batch(
+                    ModelingCmdMeta::new(self, SourceRange::new(program.end, program.end, program.module_id)),
                     // True here tells the engine to flush all the end commands as well like fillets
                     // and chamfers where the engine would otherwise eat the ID of the segments.
                     true,
-                    SourceRange::new(program.end, program.end, program.module_id),
                 )
                 .await?;
         }
@@ -535,12 +538,12 @@ impl ExecutorContext {
 
         let result = match &mut repr {
             ModuleRepr::Root => Err(exec_state.circular_import_error(&path, source_range)),
-            ModuleRepr::Kcl(_, Some((_, env_ref, items))) => Ok((*env_ref, items.clone())),
+            ModuleRepr::Kcl(_, Some((_, env_ref, items, _))) => Ok((*env_ref, items.clone())),
             ModuleRepr::Kcl(program, cache) => self
                 .exec_module_from_ast(program, module_id, &path, exec_state, source_range, false)
                 .await
-                .map(|(val, er, items)| {
-                    *cache = Some((val, er, items.clone()));
+                .map(|(val, er, items, module_artifacts)| {
+                    *cache = Some((val, er, items.clone(), module_artifacts.clone()));
                     (er, items)
                 }),
             ModuleRepr::Foreign(geom, _) => Err(KclError::new_semantic(KclErrorDetails::new(
@@ -566,28 +569,28 @@ impl ExecutorContext {
 
         let result = match &mut repr {
             ModuleRepr::Root => Err(exec_state.circular_import_error(&path, source_range)),
-            ModuleRepr::Kcl(_, Some((val, _, _))) => Ok(val.clone()),
+            ModuleRepr::Kcl(_, Some((val, _, _, _))) => Ok(val.clone()),
             ModuleRepr::Kcl(program, cached_items) => {
                 let result = self
                     .exec_module_from_ast(program, module_id, &path, exec_state, source_range, false)
                     .await;
                 match result {
-                    Ok((val, env, items)) => {
-                        *cached_items = Some((val.clone(), env, items));
+                    Ok((val, env, items, module_artifacts)) => {
+                        *cached_items = Some((val.clone(), env, items, module_artifacts));
                         Ok(val)
                     }
                     Err(e) => Err(e),
                 }
             }
-            ModuleRepr::Foreign(_, Some(imported)) => Ok(Some(imported.clone())),
+            ModuleRepr::Foreign(_, Some((imported, _))) => Ok(imported.clone()),
             ModuleRepr::Foreign(geom, cached) => {
-                let result = super::import::send_to_engine(geom.clone(), self)
+                let result = super::import::send_to_engine(geom.clone(), exec_state, self)
                     .await
                     .map(|geom| Some(KclValue::ImportedGeometry(geom)));
 
                 match result {
                     Ok(val) => {
-                        *cached = val.clone();
+                        *cached = Some((val.clone(), exec_state.mod_local.artifacts.clone()));
                         Ok(val)
                     }
                     Err(e) => Err(e),
@@ -609,7 +612,7 @@ impl ExecutorContext {
         exec_state: &mut ExecState,
         source_range: SourceRange,
         preserve_mem: bool,
-    ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>), KclError> {
+    ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>, ModuleArtifactState), KclError> {
         exec_state.global.mod_loader.enter_module(path);
         let result = self
             .exec_module_body(program, exec_state, preserve_mem, module_id, path)

rust/kcl-lib/src/execution/import.rs

@@ -15,7 +15,10 @@ use uuid::Uuid;
 
 use crate::{
     errors::{KclError, KclErrorDetails},
-    execution::{annotations, typed_path::TypedPath, types::UnitLen, ExecState, ExecutorContext, ImportedGeometry},
+    execution::{
+        annotations, typed_path::TypedPath, types::UnitLen, ExecState, ExecutorContext, ImportedGeometry,
+        ModelingCmdMeta,
+    },
     fs::FileSystem,
     parsing::ast::types::{Annotation, Node},
     source_range::SourceRange,
@@ -257,15 +260,22 @@ pub struct PreImportedGeometry {
     pub source_range: SourceRange,
 }
 
-pub async fn send_to_engine(pre: PreImportedGeometry, ctxt: &ExecutorContext) -> Result<ImportedGeometry, KclError> {
+pub async fn send_to_engine(
+    pre: PreImportedGeometry,
+    exec_state: &mut ExecState,
+    ctxt: &ExecutorContext,
+) -> Result<ImportedGeometry, KclError> {
     let imported_geometry = ImportedGeometry::new(
         pre.id,
         pre.command.files.iter().map(|f| f.path.to_string()).collect(),
         vec![pre.source_range.into()],
     );
 
-    ctxt.engine
-        .async_modeling_cmd(pre.id, pre.source_range, &ModelingCmd::from(pre.command.clone()))
+    exec_state
+        .async_modeling_cmd(
+            ModelingCmdMeta::with_id(ctxt, pre.source_range, pre.id),
+            &ModelingCmd::from(pre.command.clone()),
+        )
         .await?;
 
     Ok(imported_geometry)

rust/kcl-lib/src/execution/mod.rs

@@ -22,8 +22,10 @@ use kcmc::{
 };
 use kittycad_modeling_cmds::{self as kcmc, id::ModelingCmdId};
 pub use memory::EnvironmentRef;
+pub(crate) use modeling::ModelingCmdMeta;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+pub(crate) use state::ModuleArtifactState;
 pub use state::{ExecState, MetaSettings};
 use uuid::Uuid;
 
@@ -56,6 +58,7 @@ mod import;
 mod import_graph;
 pub(crate) mod kcl_value;
 mod memory;
+mod modeling;
 mod state;
 pub mod typed_path;
 pub(crate) mod types;
@@ -76,9 +79,6 @@ pub struct ExecOutcome {
     /// the Feature Tree.
     #[cfg(feature = "artifact-graph")]
     pub operations: Vec<Operation>,
-    /// Output commands to allow building the artifact graph by the caller.
-    #[cfg(feature = "artifact-graph")]
-    pub artifact_commands: Vec<ArtifactCommand>,
     /// Output artifact graph.
     #[cfg(feature = "artifact-graph")]
     pub artifact_graph: ArtifactGraph,
@@ -575,7 +575,7 @@ impl ExecutorContext {
 
         let mut mem = exec_state.stack().clone();
         let module_infos = exec_state.global.module_infos.clone();
-        let outcome = exec_state.to_mock_exec_outcome(result.0, self).await;
+        let outcome = exec_state.into_mock_exec_outcome(result.0, self).await;
 
         mem.squash_env(result.0);
         cache::write_old_memory((mem, module_infos)).await;
@@ -773,15 +773,12 @@ impl ExecutorContext {
         ))
         .await;
 
-        let outcome = exec_state.to_exec_outcome(result.0, self).await;
+        let outcome = exec_state.into_exec_outcome(result.0, self).await;
         Ok(outcome)
     }
 
     /// Perform the execution of a program.
     ///
-    /// You can optionally pass in some initialization memory for partial
-    /// execution.
-    ///
     /// To access non-fatal errors and warnings, extract them from the `ExecState`.
     pub async fn run(
         &self,
@@ -794,9 +791,6 @@ impl ExecutorContext {
     /// Perform the execution of a program using a concurrent
     /// execution model.
     ///
-    /// You can optionally pass in some initialization memory for partial
-    /// execution.
-    ///
     /// To access non-fatal errors and warnings, extract them from the `ExecState`.
     pub async fn run_concurrent(
         &self,
@@ -842,6 +836,8 @@ impl ExecutorContext {
                 let module_id = *module_id;
                 let module_path = module_path.clone();
                 let source_range = SourceRange::from(import_stmt);
+                // Clone before mutating.
+                let module_exec_state = exec_state.clone();
 
                 self.add_import_module_ops(
                     exec_state,
@@ -853,7 +849,6 @@ impl ExecutorContext {
                 );
 
                 let repr = repr.clone();
-                let exec_state = exec_state.clone();
                 let exec_ctxt = self.clone();
                 let results_tx = results_tx.clone();
 
@@ -873,11 +868,13 @@ impl ExecutorContext {
                             result.map(|val| ModuleRepr::Kcl(program.clone(), Some(val)))
                         }
                         ModuleRepr::Foreign(geom, _) => {
-                            let result = crate::execution::import::send_to_engine(geom.clone(), exec_ctxt)
+                            let result = crate::execution::import::send_to_engine(geom.clone(), exec_state, exec_ctxt)
                                 .await
                                 .map(|geom| Some(KclValue::ImportedGeometry(geom)));
 
-                            result.map(|val| ModuleRepr::Foreign(geom.clone(), val))
+                            result.map(|val| {
+                                ModuleRepr::Foreign(geom.clone(), Some((val, exec_state.mod_local.artifacts.clone())))
+                            })
                         }
                         ModuleRepr::Dummy | ModuleRepr::Root => Err(KclError::new_internal(KclErrorDetails::new(
                             format!("Module {module_path} not found in universe"),
@@ -889,7 +886,7 @@ impl ExecutorContext {
                 #[cfg(target_arch = "wasm32")]
                 {
                     wasm_bindgen_futures::spawn_local(async move {
-                        let mut exec_state = exec_state;
+                        let mut exec_state = module_exec_state;
                         let exec_ctxt = exec_ctxt;
 
                         let result = exec_module(
@@ -911,7 +908,7 @@ impl ExecutorContext {
                 #[cfg(not(target_arch = "wasm32"))]
                 {
                     set.spawn(async move {
-                        let mut exec_state = exec_state;
+                        let mut exec_state = module_exec_state;
                         let exec_ctxt = exec_ctxt;
 
                         let result = exec_module(
@@ -964,6 +961,15 @@ impl ExecutorContext {
             }
         }
 
+        // Since we haven't technically started executing the root module yet,
+        // the operations corresponding to the imports will be missing unless we
+        // track them here.
+        #[cfg(all(test, feature = "artifact-graph"))]
+        exec_state
+            .global
+            .root_module_artifacts
+            .extend(exec_state.mod_local.artifacts.clone());
+
         self.inner_run(program, exec_state, preserve_mem).await
     }
 
@@ -993,6 +999,18 @@ impl ExecutorContext {
         Ok((universe, root_imports))
     }
 
+    #[cfg(not(feature = "artifact-graph"))]
+    fn add_import_module_ops(
+        &self,
+        _exec_state: &mut ExecState,
+        _program: &crate::Program,
+        _module_id: ModuleId,
+        _module_path: &ModulePath,
+        _source_range: SourceRange,
+        _universe_map: &UniverseMap,
+    ) {
+    }
+
     #[cfg(feature = "artifact-graph")]
     fn add_import_module_ops(
         &self,
@@ -1042,18 +1060,6 @@ impl ExecutorContext {
         }
     }
 
-    #[cfg(not(feature = "artifact-graph"))]
-    fn add_import_module_ops(
-        &self,
-        _exec_state: &mut ExecState,
-        _program: &crate::Program,
-        _module_id: ModuleId,
-        _module_path: &ModulePath,
-        _source_range: SourceRange,
-        _universe_map: &UniverseMap,
-    ) {
-    }
-
     /// Perform the execution of a program.  Accept all possible parameters and
     /// output everything.
     async fn inner_run(
@@ -1121,26 +1127,32 @@ impl ExecutorContext {
                 &ModulePath::Main,
             )
             .await;
+        #[cfg(all(test, feature = "artifact-graph"))]
+        let exec_result = exec_result.map(|(_, env_ref, _, module_artifacts)| {
+            exec_state.global.root_module_artifacts.extend(module_artifacts);
+            env_ref
+        });
+        #[cfg(not(all(test, feature = "artifact-graph")))]
+        let exec_result = exec_result.map(|(_, env_ref, _, _)| env_ref);
 
         #[cfg(feature = "artifact-graph")]
         {
             // Fill in NodePath for operations.
             let cached_body_items = exec_state.global.artifacts.cached_body_items();
             for op in exec_state.global.artifacts.operations.iter_mut().skip(start_op) {
-                match op {
-                    Operation::StdLibCall {
-                        node_path,
-                        source_range,
-                        ..
+                op.fill_node_paths(program, cached_body_items);
+            }
+            #[cfg(test)]
+            {
+                for op in exec_state.global.root_module_artifacts.operations.iter_mut() {
+                    op.fill_node_paths(program, cached_body_items);
+                }
+                for module in exec_state.global.module_infos.values_mut() {
+                    if let ModuleRepr::Kcl(_, Some((_, _, _, module_artifacts))) = &mut module.repr {
+                        for op in &mut module_artifacts.operations {
+                            op.fill_node_paths(program, cached_body_items);
                         }
-                    | Operation::GroupBegin {
-                        node_path,
-                        source_range,
-                        ..
-                    } => {
-                        node_path.fill_placeholder(program, cached_body_items, *source_range);
                     }
-                    Operation::GroupEnd => {}
                 }
             }
         }
@@ -1153,7 +1165,7 @@ impl ExecutorContext {
         self.engine.clear_queues().await;
 
         match exec_state.build_artifact_graph(&self.engine, program).await {
-            Ok(_) => exec_result.map(|(_, env_ref, _)| env_ref),
+            Ok(_) => exec_result,
             Err(err) => exec_result.and(Err(err)),
         }
     }

rust/kcl-lib/src/execution/modeling.rs

@@ -0,0 +1,224 @@
+use kcmc::ModelingCmd;
+use kittycad_modeling_cmds::{
+    self as kcmc,
+    websocket::{ModelingCmdReq, OkWebSocketResponseData},
+};
+use uuid::Uuid;
+
+#[cfg(feature = "artifact-graph")]
+use crate::exec::ArtifactCommand;
+use crate::{
+    exec::{IdGenerator, KclValue},
+    execution::Solid,
+    std::Args,
+    ExecState, ExecutorContext, KclError, SourceRange,
+};
+
+/// Context and metadata needed to send a single modeling command.
+///
+/// Many functions consume Self so that the command ID isn't accidentally reused
+/// among multiple modeling commands.
+pub(crate) struct ModelingCmdMeta<'a> {
+    /// The executor context, which contains the engine.
+    pub ctx: &'a ExecutorContext,
+    /// The source range of the command, used for error reporting.
+    pub source_range: SourceRange,
+    /// The id of the command, if it has been set by the caller or generated.
+    id: Option<Uuid>,
+}
+
+impl<'a> ModelingCmdMeta<'a> {
+    pub fn new(ctx: &'a ExecutorContext, source_range: SourceRange) -> Self {
+        ModelingCmdMeta {
+            ctx,
+            source_range,
+            id: None,
+        }
+    }
+
+    pub fn with_id(ctx: &'a ExecutorContext, source_range: SourceRange, id: Uuid) -> Self {
+        ModelingCmdMeta {
+            ctx,
+            source_range,
+            id: Some(id),
+        }
+    }
+
+    pub fn from_args_id(args: &'a Args, id: Uuid) -> Self {
+        ModelingCmdMeta {
+            ctx: &args.ctx,
+            source_range: args.source_range,
+            id: Some(id),
+        }
+    }
+
+    pub fn id(&mut self, id_generator: &mut IdGenerator) -> Uuid {
+        if let Some(id) = self.id {
+            return id;
+        }
+        let id = id_generator.next_uuid();
+        self.id = Some(id);
+        id
+    }
+}
+
+impl<'a> From<&'a Args> for ModelingCmdMeta<'a> {
+    fn from(args: &'a Args) -> Self {
+        ModelingCmdMeta::new(&args.ctx, args.source_range)
+    }
+}
+
+impl ExecState {
+    /// Add a modeling command to the batch but don't fire it right away.
+    pub(crate) async fn batch_modeling_cmd(
+        &mut self,
+        mut meta: ModelingCmdMeta<'_>,
+        cmd: ModelingCmd,
+    ) -> Result<(), crate::errors::KclError> {
+        let id = meta.id(self.id_generator());
+        #[cfg(feature = "artifact-graph")]
+        self.push_command(ArtifactCommand {
+            cmd_id: id,
+            range: meta.source_range,
+            command: cmd.clone(),
+        });
+        meta.ctx.engine.batch_modeling_cmd(id, meta.source_range, &cmd).await
+    }
+
+    /// Add multiple modeling commands to the batch but don't fire them right
+    /// away.
+    pub(crate) async fn batch_modeling_cmds(
+        &mut self,
+        meta: ModelingCmdMeta<'_>,
+        cmds: &[ModelingCmdReq],
+    ) -> Result<(), crate::errors::KclError> {
+        #[cfg(feature = "artifact-graph")]
+        for cmd_req in cmds {
+            self.push_command(ArtifactCommand {
+                cmd_id: *cmd_req.cmd_id.as_ref(),
+                range: meta.source_range,
+                command: cmd_req.cmd.clone(),
+            });
+        }
+        meta.ctx.engine.batch_modeling_cmds(meta.source_range, cmds).await
+    }
+
+    /// Add a modeling command to the batch that gets executed at the end of the
+    /// file. This is good for something like fillet or chamfer where the engine
+    /// would eat the path id if we executed it right away.
+    pub(crate) async fn batch_end_cmd(
+        &mut self,
+        mut meta: ModelingCmdMeta<'_>,
+        cmd: ModelingCmd,
+    ) -> Result<(), crate::errors::KclError> {
+        let id = meta.id(self.id_generator());
+        // TODO: The order of the tracking of these doesn't match the order that
+        // they're sent to the engine.
+        #[cfg(feature = "artifact-graph")]
+        self.push_command(ArtifactCommand {
+            cmd_id: id,
+            range: meta.source_range,
+            command: cmd.clone(),
+        });
+        meta.ctx.engine.batch_end_cmd(id, meta.source_range, &cmd).await
+    }
+
+    /// Send the modeling cmd and wait for the response.
+    pub(crate) async fn send_modeling_cmd(
+        &mut self,
+        mut meta: ModelingCmdMeta<'_>,
+        cmd: ModelingCmd,
+    ) -> Result<OkWebSocketResponseData, KclError> {
+        let id = meta.id(self.id_generator());
+        #[cfg(feature = "artifact-graph")]
+        self.push_command(ArtifactCommand {
+            cmd_id: id,
+            range: meta.source_range,
+            command: cmd.clone(),
+        });
+        meta.ctx.engine.send_modeling_cmd(id, meta.source_range, &cmd).await
+    }
+
+    /// Send the modeling cmd async and don't wait for the response.
+    /// Add it to our list of async commands.
+    pub(crate) async fn async_modeling_cmd(
+        &mut self,
+        mut meta: ModelingCmdMeta<'_>,
+        cmd: &ModelingCmd,
+    ) -> Result<(), crate::errors::KclError> {
+        let id = meta.id(self.id_generator());
+        #[cfg(feature = "artifact-graph")]
+        self.push_command(ArtifactCommand {
+            cmd_id: id,
+            range: meta.source_range,
+            command: cmd.clone(),
+        });
+        meta.ctx.engine.async_modeling_cmd(id, meta.source_range, cmd).await
+    }
+
+    /// Force flush the batch queue.
+    pub(crate) async fn flush_batch(
+        &mut self,
+        meta: ModelingCmdMeta<'_>,
+        // Whether or not to flush the end commands as well.
+        // We only do this at the very end of the file.
+        batch_end: bool,
+    ) -> Result<OkWebSocketResponseData, KclError> {
+        meta.ctx.engine.flush_batch(batch_end, meta.source_range).await
+    }
+
+    /// Flush just the fillets and chamfers for this specific SolidSet.
+    pub(crate) async fn flush_batch_for_solids(
+        &mut self,
+        meta: ModelingCmdMeta<'_>,
+        solids: &[Solid],
+    ) -> Result<(), KclError> {
+        // Make sure we don't traverse sketches more than once.
+        let mut traversed_sketches = Vec::new();
+
+        // Collect all the fillet/chamfer ids for the solids.
+        let mut ids = Vec::new();
+        for solid in solids {
+            // We need to traverse the solids that share the same sketch.
+            let sketch_id = solid.sketch.id;
+            if !traversed_sketches.contains(&sketch_id) {
+                // Find all the solids on the same shared sketch.
+                ids.extend(
+                    self.stack()
+                        .walk_call_stack()
+                        .filter(|v| matches!(v, KclValue::Solid { value } if value.sketch.id == sketch_id))
+                        .flat_map(|v| match v {
+                            KclValue::Solid { value } => value.get_all_edge_cut_ids(),
+                            _ => unreachable!(),
+                        }),
+                );
+                traversed_sketches.push(sketch_id);
+            }
+
+            ids.extend(solid.get_all_edge_cut_ids());
+        }
+
+        // We can return early if there are no fillets or chamfers.
+        if ids.is_empty() {
+            return Ok(());
+        }
+
+        // We want to move these fillets and chamfers from batch_end to batch so they get executed
+        // before what ever we call next.
+        for id in ids {
+            // Pop it off the batch_end and add it to the batch.
+            let Some(item) = meta.ctx.engine.batch_end().write().await.shift_remove(&id) else {
+                // It might be in the batch already.
+                continue;
+            };
+            // Add it to the batch.
+            meta.ctx.engine.batch().write().await.push(item);
+        }
+
+        // Run flush.
+        // Yes, we do need to actually flush the batch here, or references will fail later.
+        self.flush_batch(meta, false).await?;
+
+        Ok(())
+    }
+}

rust/kcl-lib/src/execution/state.rs

@@ -3,7 +3,9 @@ use std::sync::Arc;
 use anyhow::Result;
 use indexmap::IndexMap;
 #[cfg(feature = "artifact-graph")]
-use kittycad_modeling_cmds::websocket::WebSocketResponse;
+use kcmc::websocket::WebSocketResponse;
+#[cfg(feature = "artifact-graph")]
+use kittycad_modeling_cmds as kcmc;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
@@ -50,6 +52,8 @@ pub(super) struct GlobalState {
     pub errors: Vec<CompilationError>,
     #[cfg_attr(not(feature = "artifact-graph"), allow(dead_code))]
     pub artifacts: ArtifactState,
+    #[cfg_attr(not(all(test, feature = "artifact-graph")), expect(dead_code))]
+    pub root_module_artifacts: ModuleArtifactState,
 }
 
 #[cfg(feature = "artifact-graph")]
@@ -77,6 +81,20 @@ pub(super) struct ArtifactState {
 #[derive(Debug, Clone, Default)]
 pub(super) struct ArtifactState {}
 
+/// Artifact state for a single module.
+#[cfg(all(test, feature = "artifact-graph"))]
+#[derive(Debug, Clone, Default, PartialEq, Serialize)]
+pub struct ModuleArtifactState {
+    /// Outgoing engine commands.
+    pub commands: Vec<ArtifactCommand>,
+    /// Operations that have been performed in execution order.
+    pub operations: Vec<Operation>,
+}
+
+#[cfg(not(all(test, feature = "artifact-graph")))]
+#[derive(Debug, Clone, Default, PartialEq, Serialize)]
+pub struct ModuleArtifactState {}
+
 #[derive(Debug, Clone)]
 pub(super) struct ModuleState {
     /// The id generator for this module.
@@ -96,6 +114,7 @@ pub(super) struct ModuleState {
     pub settings: MetaSettings,
     pub(super) explicit_length_units: bool,
     pub(super) path: ModulePath,
+    pub artifacts: ModuleArtifactState,
 }
 
 impl ExecState {
@@ -133,7 +152,7 @@ impl ExecState {
     /// Convert to execution outcome when running in WebAssembly.  We want to
     /// reduce the amount of data that crosses the WASM boundary as much as
     /// possible.
-    pub async fn to_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
+    pub async fn into_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
         // Fields are opt-in so that we don't accidentally leak private internal
         // state when we add more to ExecState.
         ExecOutcome {
@@ -142,22 +161,18 @@ impl ExecState {
             #[cfg(feature = "artifact-graph")]
             operations: self.global.artifacts.operations,
             #[cfg(feature = "artifact-graph")]
-            artifact_commands: self.global.artifacts.commands,
-            #[cfg(feature = "artifact-graph")]
             artifact_graph: self.global.artifacts.graph,
             errors: self.global.errors,
             default_planes: ctx.engine.get_default_planes().read().await.clone(),
         }
     }
 
-    pub async fn to_mock_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
+    pub async fn into_mock_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
         ExecOutcome {
             variables: self.mod_local.variables(main_ref),
             #[cfg(feature = "artifact-graph")]
             operations: Default::default(),
             #[cfg(feature = "artifact-graph")]
-            artifact_commands: Default::default(),
-            #[cfg(feature = "artifact-graph")]
             artifact_graph: Default::default(),
             errors: self.global.errors,
             filenames: Default::default(),
@@ -188,12 +203,22 @@ impl ExecState {
     }
 
     pub(crate) fn push_op(&mut self, op: Operation) {
+        #[cfg(all(test, feature = "artifact-graph"))]
+        self.mod_local.artifacts.operations.push(op.clone());
         #[cfg(feature = "artifact-graph")]
         self.global.artifacts.operations.push(op);
         #[cfg(not(feature = "artifact-graph"))]
         drop(op);
     }
 
+    #[cfg(feature = "artifact-graph")]
+    pub(crate) fn push_command(&mut self, command: ArtifactCommand) {
+        #[cfg(all(test, feature = "artifact-graph"))]
+        self.mod_local.artifacts.commands.push(command);
+        #[cfg(not(all(test, feature = "artifact-graph")))]
+        drop(command);
+    }
+
     pub(super) fn next_module_id(&self) -> ModuleId {
         ModuleId::from_usize(self.global.path_to_source_id.len())
     }
@@ -241,6 +266,21 @@ impl ExecState {
         self.global.module_infos.get(&id)
     }
 
+    #[cfg(all(test, feature = "artifact-graph"))]
+    pub(crate) fn modules(&self) -> &ModuleInfoMap {
+        &self.global.module_infos
+    }
+
+    #[cfg(all(test, feature = "artifact-graph"))]
+    pub(crate) fn operations(&self) -> &[Operation] {
+        &self.global.artifacts.operations
+    }
+
+    #[cfg(all(test, feature = "artifact-graph"))]
+    pub(crate) fn root_module_artifact_state(&self) -> &ModuleArtifactState {
+        &self.global.root_module_artifacts
+    }
+
     pub fn current_default_units(&self) -> NumericType {
         NumericType::Default {
             len: self.length_unit(),
@@ -349,6 +389,7 @@ impl GlobalState {
             path_to_source_id: Default::default(),
             module_infos: Default::default(),
             artifacts: Default::default(),
+            root_module_artifacts: Default::default(),
             mod_loader: Default::default(),
             errors: Default::default(),
             id_to_source: Default::default(),
@@ -388,6 +429,15 @@ impl ArtifactState {
     }
 }
 
+impl ModuleArtifactState {
+    /// When self is a cached state, extend it with new state.
+    #[cfg(all(test, feature = "artifact-graph"))]
+    pub(crate) fn extend(&mut self, other: ModuleArtifactState) {
+        self.commands.extend(other.commands);
+        self.operations.extend(other.operations);
+    }
+}
+
 impl ModuleState {
     pub(super) fn new(path: ModulePath, memory: Arc<ProgramMemory>, module_id: Option<ModuleId>) -> Self {
         ModuleState {
@@ -403,6 +453,7 @@ impl ModuleState {
                 default_angle_units: Default::default(),
                 kcl_version: "0.1".to_owned(),
             },
+            artifacts: Default::default(),
         }
     }
 

rust/kcl-lib/src/execution/typed_path.rs

@@ -104,6 +104,16 @@ impl TypedPath {
         }
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn strip_prefix(&self, base: impl AsRef<std::path::Path>) -> Result<Self, std::path::StripPrefixError> {
+        self.0.strip_prefix(base).map(|p| TypedPath(p.to_path_buf()))
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub fn canonicalize(&self) -> Result<Self, std::io::Error> {
+        self.0.canonicalize().map(|p| TypedPath(p.to_path_buf()))
+    }
+
     pub fn to_string_lossy(&self) -> String {
         #[cfg(target_arch = "wasm32")]
         {

rust/kcl-lib/src/modules.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use crate::{
     errors::{KclError, KclErrorDetails},
     exec::KclValue,
-    execution::{typed_path::TypedPath, EnvironmentRef, PreImportedGeometry},
+    execution::{typed_path::TypedPath, EnvironmentRef, ModuleArtifactState, PreImportedGeometry},
     fs::{FileManager, FileSystem},
     parsing::ast::types::{ImportPath, Node, Program},
     source_range::SourceRange,
@@ -131,8 +131,11 @@ impl ModuleInfo {
 pub enum ModuleRepr {
     Root,
     // AST, memory, exported names
-    Kcl(Node<Program>, Option<(Option<KclValue>, EnvironmentRef, Vec<String>)>),
-    Foreign(PreImportedGeometry, Option<KclValue>),
+    Kcl(
+        Node<Program>,
+        Option<(Option<KclValue>, EnvironmentRef, Vec<String>, ModuleArtifactState)>,
+    ),
+    Foreign(PreImportedGeometry, Option<(Option<KclValue>, ModuleArtifactState)>),
     Dummy,
 }
 

rust/kcl-lib/src/simulation_tests.rs

@@ -3,13 +3,18 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use indexmap::IndexMap;
 use insta::rounded_redaction;
 
-use crate::{errors::KclError, ModuleId};
+use crate::{
+    errors::KclError,
+    execution::{EnvironmentRef, ModuleArtifactState},
+    ExecOutcome, ExecState, ExecutorContext, ModuleId,
+};
 #[cfg(feature = "artifact-graph")]
 use crate::{
-    exec::ArtifactCommand,
     execution::{ArtifactGraph, Operation},
+    modules::{ModulePath, ModuleRepr},
 };
 
 mod kcl_samples;
@@ -19,8 +24,7 @@ mod kcl_samples;
 struct Test {
     /// The name of the test.
     name: String,
-    /// The name of the KCL file that's the entry point, e.g. "main.kcl", in the
-    /// `input_dir`.
+    /// The KCL file that's the entry point, e.g. "main.kcl", in the `input_dir`.
     entry_point: PathBuf,
     /// Input KCL files are in this directory.
     input_dir: PathBuf,
@@ -34,6 +38,9 @@ struct Test {
 
 pub(crate) const RENDERED_MODEL_NAME: &str = "rendered_model.png";
 
+#[cfg(feature = "artifact-graph")]
+const REPO_ROOT: &str = "../..";
+
 impl Test {
     fn new(name: &str) -> Self {
         Self {
@@ -52,6 +59,75 @@ impl Test {
     }
 }
 
+impl ExecState {
+    /// Same as [`Self::into_exec_outcome`], but also returns the module state.
+    async fn into_test_exec_outcome(
+        self,
+        main_ref: EnvironmentRef,
+        ctx: &ExecutorContext,
+        project_directory: &Path,
+    ) -> (ExecOutcome, IndexMap<String, ModuleArtifactState>) {
+        let module_state = self.to_module_state(project_directory);
+        let outcome = self.into_exec_outcome(main_ref, ctx).await;
+        (outcome, module_state)
+    }
+
+    #[cfg(not(feature = "artifact-graph"))]
+    fn to_module_state(&self, _project_directory: &Path) -> IndexMap<String, ModuleArtifactState> {
+        Default::default()
+    }
+
+    /// The keys of the map are the module paths.  Can't use `ModulePath` since
+    /// it needs to be converted to a string to be a JSON object key.  The paths
+    /// need to be relative so that generating locally works in CI.
+    #[cfg(feature = "artifact-graph")]
+    fn to_module_state(&self, _project_directory: &Path) -> IndexMap<String, ModuleArtifactState> {
+        let project_directory = std::path::Path::new(REPO_ROOT)
+            .canonicalize()
+            .unwrap_or_else(|_| panic!("Failed to canonicalize project directory: {REPO_ROOT}"));
+        let mut module_state = IndexMap::new();
+        for info in self.modules().values() {
+            let relative_path = relative_module_path(&info.path, &project_directory).unwrap_or_else(|err| {
+                panic!(
+                    "Failed to get relative module path for {:?} in {:?}; caused by {err:?}",
+                    &info.path, project_directory
+                )
+            });
+            match &info.repr {
+                ModuleRepr::Root => {
+                    module_state.insert(relative_path, self.root_module_artifact_state().clone());
+                }
+                ModuleRepr::Kcl(_, None) => {
+                    module_state.insert(relative_path, Default::default());
+                }
+                ModuleRepr::Kcl(_, Some((_, _, _, module_artifacts))) => {
+                    module_state.insert(relative_path, module_artifacts.clone());
+                }
+                ModuleRepr::Foreign(_, Some((_, module_artifacts))) => {
+                    module_state.insert(relative_path, module_artifacts.clone());
+                }
+                ModuleRepr::Foreign(_, None) | ModuleRepr::Dummy => {}
+            }
+        }
+        module_state
+    }
+}
+
+#[cfg(feature = "artifact-graph")]
+fn relative_module_path(module_path: &ModulePath, abs_project_directory: &Path) -> Result<String, std::io::Error> {
+    match module_path {
+        ModulePath::Main => Ok("main".to_owned()),
+        ModulePath::Local { value: path } => {
+            let abs_path = path.canonicalize()?;
+            abs_path
+                .strip_prefix(abs_project_directory)
+                .map(|p| p.to_string_lossy())
+                .map_err(|_| std::io::Error::other(format!("Failed to strip prefix from module path {abs_path:?}")))
+        }
+        ModulePath::Std { value } => Ok(format!("std::{value}")),
+    }
+}
+
 fn assert_snapshot<F, R>(test: &Test, operation: &str, f: F)
 where
     F: FnOnce() -> R,
@@ -181,7 +257,7 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
                     panic!("Step data was empty");
                 }
             }
-            let outcome = exec_state.to_exec_outcome(env_ref, &ctx).await;
+            let (outcome, module_state) = exec_state.into_test_exec_outcome(env_ref, &ctx, &test.input_dir).await;
 
             let mem_result = catch_unwind(AssertUnwindSafe(|| {
                 assert_snapshot(test, "Variables in memory after executing", || {
@@ -202,13 +278,10 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
                 })
             }));
 
+            #[cfg(not(feature = "artifact-graph"))]
+            drop(module_state);
             #[cfg(feature = "artifact-graph")]
-            assert_common_snapshots(
-                test,
-                outcome.operations,
-                outcome.artifact_commands,
-                outcome.artifact_graph,
-            );
+            assert_artifact_snapshots(test, module_state, outcome.operations, outcome.artifact_graph);
             mem_result.unwrap();
         }
         Err(e) => {
@@ -238,7 +311,23 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
                     }));
 
                     #[cfg(feature = "artifact-graph")]
-                    assert_common_snapshots(test, error.operations, error.artifact_commands, error.artifact_graph);
+                    {
+                        let global_operations = if !error.operations.is_empty() {
+                            error.operations
+                        } else if let Some(exec_state) = &e.exec_state {
+                            // Non-fatal compilation errors don't have artifact
+                            // output attached, so we need to get it from
+                            // ExecState.
+                            exec_state.operations().to_vec()
+                        } else {
+                            Vec::new()
+                        };
+                        let module_state = e
+                            .exec_state
+                            .map(|e| e.to_module_state(&test.input_dir))
+                            .unwrap_or_default();
+                        assert_artifact_snapshots(test, module_state, global_operations, error.artifact_graph);
+                    }
                     err_result.unwrap();
                 }
                 e => {
@@ -252,56 +341,44 @@ async fn execute_test(test: &Test, render_to_png: bool, export_step: bool) {
     }
 }
 
-/// Assert snapshots that should happen both when KCL execution succeeds and
-/// when it results in an error.
+/// Assert snapshots for artifacts that should happen both when KCL execution
+/// succeeds and when it results in an error.
 #[cfg(feature = "artifact-graph")]
-fn assert_common_snapshots(
+fn assert_artifact_snapshots(
     test: &Test,
-    operations: Vec<Operation>,
-    artifact_commands: Vec<ArtifactCommand>,
+    module_state: IndexMap<String, ModuleArtifactState>,
+    global_operations: Vec<Operation>,
     artifact_graph: ArtifactGraph,
 ) {
-    let operations = {
-        // Make the operations deterministic by sorting them by their module ID,
-        // then by their range.
-        let mut operations = operations.clone();
-        operations.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
-        operations
-    };
-    let artifact_commands = {
-        // Due to our newfound concurrency, we're going to mess with the
-        // artifact_commands a bit -- we're going to maintain the order,
-        // but only for a given module ID. This means the artifact_commands
-        // is no longer meaningful, but it is deterministic and will hopefully
-        // catch meaningful changes in behavior.
-        // We sort by the source range, like we do for the operations.
-
-        let mut artifact_commands = artifact_commands.clone();
-        artifact_commands.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
-        artifact_commands
-    };
-
+    let module_operations = module_state
+        .iter()
+        .map(|(path, s)| (path, &s.operations))
+        .collect::<IndexMap<_, _>>();
     let result1 = catch_unwind(AssertUnwindSafe(|| {
         assert_snapshot(test, "Operations executed", || {
-            insta::assert_json_snapshot!("ops", operations, {
-                "[].*.unlabeledArg.*.value.**[].from[]" => rounded_redaction(3),
-                "[].*.unlabeledArg.*.value.**[].to[]" => rounded_redaction(3),
-                "[].**.value.value" => rounded_redaction(3),
-                "[].*.labeledArgs.*.value.**[].from[]" => rounded_redaction(3),
-                "[].*.labeledArgs.*.value.**[].to[]" => rounded_redaction(3),
+            insta::assert_json_snapshot!("ops", module_operations, {
+                ".*[].*.unlabeledArg.*.value.**[].from[]" => rounded_redaction(3),
+                ".*[].*.unlabeledArg.*.value.**[].to[]" => rounded_redaction(3),
+                ".*[].**.value.value" => rounded_redaction(3),
+                ".*[].*.labeledArgs.*.value.**[].from[]" => rounded_redaction(3),
+                ".*[].*.labeledArgs.*.value.**[].to[]" => rounded_redaction(3),
                 ".**.sourceRange" => Vec::new(),
                 ".**.functionSourceRange" => Vec::new(),
                 ".**.moduleId" => 0,
             });
         })
     }));
+    let module_commands = module_state
+        .iter()
+        .map(|(path, s)| (path, &s.commands))
+        .collect::<IndexMap<_, _>>();
     let result2 = catch_unwind(AssertUnwindSafe(|| {
         assert_snapshot(test, "Artifact commands", || {
-            insta::assert_json_snapshot!("artifact_commands", artifact_commands, {
-                "[].command.**.value" => rounded_redaction(3),
-                "[].command.**.x" => rounded_redaction(3),
-                "[].command.**.y" => rounded_redaction(3),
-                "[].command.**.z" => rounded_redaction(3),
+            insta::assert_json_snapshot!("artifact_commands", module_commands, {
+                ".*[].command.**.value" => rounded_redaction(3),
+                ".*[].command.**.x" => rounded_redaction(3),
+                ".*[].command.**.y" => rounded_redaction(3),
+                ".*[].command.**.z" => rounded_redaction(3),
                 ".**.range" => Vec::new(),
             });
         })
@@ -337,6 +414,25 @@ fn assert_common_snapshots(
     result1.unwrap();
     result2.unwrap();
     result3.unwrap();
+
+    // The global operations should be a superset of the main module.  But it
+    // won't always be a superset of the operations of all modules.
+    let repo_root = std::path::Path::new(REPO_ROOT).canonicalize().unwrap();
+    let root_string: String = test
+        .entry_point
+        .canonicalize()
+        .unwrap_or_else(|_| panic!("Should be able to canonicalize the entry point {:?}", &test.entry_point))
+        .strip_prefix(&repo_root)
+        .expect("Repo root dir should be a prefix of the entry point")
+        .to_string_lossy()
+        .into_owned();
+    let main_operations = module_operations
+        .get(&root_string)
+        .expect("Main module state not found");
+    assert!(
+        global_operations.len() >= main_operations.len(),
+        "global_operations={global_operations:#?}, main_operations={main_operations:#?}"
+    );
 }
 
 mod cube {

rust/kcl-lib/src/std/appearance.rs

@@ -106,8 +106,9 @@ async fn inner_appearance(
             a: 100.0,
         };
 
-        args.batch_modeling_cmd(
-            exec_state.next_uuid(),
+        exec_state
+            .batch_modeling_cmd(
+                (&args).into(),
                 ModelingCmd::from(mcmd::ObjectSetMaterialParamsPbr {
                     object_id: solid_id,
                     color,

rust/kcl-lib/src/std/args.rs

@@ -1,14 +1,10 @@
 use std::num::NonZeroU32;
 
 use anyhow::Result;
-use kcmc::{
-    websocket::{ModelingCmdReq, OkWebSocketResponseData},
-    ModelingCmd,
-};
-use kittycad_modeling_cmds as kcmc;
 use schemars::JsonSchema;
 use serde::Serialize;
 
+use super::fillet::EdgeReference;
 pub use crate::execution::fn_call::Args;
 use crate::{
     errors::{KclError, KclErrorDetails},
@@ -28,8 +24,6 @@ use crate::{
     ModuleId,
 };
 
-use super::fillet::EdgeReference;
-
 const ERROR_STRING_SKETCH_TO_SOLID_HELPER: &str =
     "You can convert a sketch (2D) into a Solid (3D) by calling a function like `extrude` or `revolve`";
 
@@ -277,36 +271,7 @@ impl Args {
         })
     }
 
-    // Add a modeling command to the batch but don't fire it right away.
-    pub(crate) async fn batch_modeling_cmd(
-        &self,
-        id: uuid::Uuid,
-        cmd: ModelingCmd,
-    ) -> Result<(), crate::errors::KclError> {
-        self.ctx.engine.batch_modeling_cmd(id, self.source_range, &cmd).await
-    }
-
-    // Add multiple modeling commands to the batch but don't fire them right away.
-    pub(crate) async fn batch_modeling_cmds(&self, cmds: &[ModelingCmdReq]) -> Result<(), crate::errors::KclError> {
-        self.ctx.engine.batch_modeling_cmds(self.source_range, cmds).await
-    }
-
-    // Add a modeling commandSolid> to the batch that gets executed at the end of the file.
-    // This is good for something like fillet or chamfer where the engine would
-    // eat the path id if we executed it right away.
-    pub(crate) async fn batch_end_cmd(&self, id: uuid::Uuid, cmd: ModelingCmd) -> Result<(), crate::errors::KclError> {
-        self.ctx.engine.batch_end_cmd(id, self.source_range, &cmd).await
-    }
-
-    /// Send the modeling cmd and wait for the response.
-    pub(crate) async fn send_modeling_cmd(
-        &self,
-        id: uuid::Uuid,
-        cmd: ModelingCmd,
-    ) -> Result<OkWebSocketResponseData, KclError> {
-        self.ctx.engine.send_modeling_cmd(id, self.source_range, &cmd).await
-    }
-
+    // TODO: Move this to the modeling module.
     fn get_tag_info_from_memory<'a, 'e>(
         &'a self,
         exec_state: &'e mut ExecState,
@@ -330,6 +295,7 @@ impl Args {
         }
     }
 
+    // TODO: Move this to the modeling module.
     pub(crate) fn get_tag_engine_info<'a, 'e>(
         &'a self,
         exec_state: &'e mut ExecState,
@@ -345,6 +311,7 @@ impl Args {
         self.get_tag_info_from_memory(exec_state, tag)
     }
 
+    // TODO: Move this to the modeling module.
     fn get_tag_engine_info_check_surface<'a, 'e>(
         &'a self,
         exec_state: &'e mut ExecState,
@@ -362,63 +329,6 @@ impl Args {
         self.get_tag_info_from_memory(exec_state, tag)
     }
 
-    /// Flush just the fillets and chamfers for this specific SolidSet.
-    #[allow(clippy::vec_box)]
-    pub(crate) async fn flush_batch_for_solids(
-        &self,
-        exec_state: &mut ExecState,
-        solids: &[Solid],
-    ) -> Result<(), KclError> {
-        // Make sure we don't traverse sketches more than once.
-        let mut traversed_sketches = Vec::new();
-
-        // Collect all the fillet/chamfer ids for the solids.
-        let mut ids = Vec::new();
-        for solid in solids {
-            // We need to traverse the solids that share the same sketch.
-            let sketch_id = solid.sketch.id;
-            if !traversed_sketches.contains(&sketch_id) {
-                // Find all the solids on the same shared sketch.
-                ids.extend(
-                    exec_state
-                        .stack()
-                        .walk_call_stack()
-                        .filter(|v| matches!(v, KclValue::Solid { value } if value.sketch.id == sketch_id))
-                        .flat_map(|v| match v {
-                            KclValue::Solid { value } => value.get_all_edge_cut_ids(),
-                            _ => unreachable!(),
-                        }),
-                );
-                traversed_sketches.push(sketch_id);
-            }
-
-            ids.extend(solid.get_all_edge_cut_ids());
-        }
-
-        // We can return early if there are no fillets or chamfers.
-        if ids.is_empty() {
-            return Ok(());
-        }
-
-        // We want to move these fillets and chamfers from batch_end to batch so they get executed
-        // before what ever we call next.
-        for id in ids {
-            // Pop it off the batch_end and add it to the batch.
-            let Some(item) = self.ctx.engine.batch_end().write().await.shift_remove(&id) else {
-                // It might be in the batch already.
-                continue;
-            };
-            // Add it to the batch.
-            self.ctx.engine.batch().write().await.push(item);
-        }
-
-        // Run flush.
-        // Yes, we do need to actually flush the batch here, or references will fail later.
-        self.ctx.engine.flush_batch(false, self.source_range).await?;
-
-        Ok(())
-    }
-
     pub(crate) fn make_kcl_val_from_point(&self, p: [f64; 2], ty: NumericType) -> Result<KclValue, KclError> {
         let meta = Metadata {
             source_range: self.source_range,
@@ -448,6 +358,7 @@ impl Args {
         )
     }
 
+    // TODO: Move this to the modeling module.
     pub(crate) async fn get_adjacent_face_to_tag(
         &self,
         exec_state: &mut ExecState,

rust/kcl-lib/src/std/chamfer.rs

@@ -7,7 +7,10 @@ use kittycad_modeling_cmds as kcmc;
 use super::args::TyF64;
 use crate::{
     errors::{KclError, KclErrorDetails},
-    execution::{types::RuntimeType, ChamferSurface, EdgeCut, ExecState, ExtrudeSurface, GeoMeta, KclValue, Solid},
+    execution::{
+        types::RuntimeType, ChamferSurface, EdgeCut, ExecState, ExtrudeSurface, GeoMeta, KclValue, ModelingCmdMeta,
+        Solid,
+    },
     parsing::ast::types::TagNode,
     std::{fillet::EdgeReference, Args},
 };
@@ -52,8 +55,9 @@ async fn inner_chamfer(
         };
 
         let id = exec_state.next_uuid();
-        args.batch_end_cmd(
-            id,
+        exec_state
+            .batch_end_cmd(
+                ModelingCmdMeta::from_args_id(&args, id),
                 ModelingCmd::from(mcmd::Solid3dFilletEdge {
                     edge_id: None,
                     edge_ids: vec![edge_id],

rust/kcl-lib/src/std/clone.rs

@@ -16,7 +16,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{NumericType, PrimitiveType, RuntimeType},
-        ExecState, GeometryWithImportedGeometry, KclValue, Sketch, Solid,
+        ExecState, GeometryWithImportedGeometry, KclValue, ModelingCmdMeta, Sketch, Solid,
     },
     parsing::ast::types::TagNode,
     std::{extrude::NamedCapTags, Args},
@@ -64,7 +64,9 @@ async fn inner_clone(
         }
         GeometryWithImportedGeometry::Solid(solid) => {
             // We flush before the clone so all the shit exists.
-            args.flush_batch_for_solids(exec_state, &[solid.clone()]).await?;
+            exec_state
+                .flush_batch_for_solids((&args).into(), &[solid.clone()])
+                .await?;
 
             let mut new_solid = solid.clone();
             new_solid.id = new_id;
@@ -78,7 +80,11 @@ async fn inner_clone(
         return Ok(new_geometry);
     }
 
-    args.batch_modeling_cmd(new_id, ModelingCmd::from(mcmd::EntityClone { entity_id: old_id }))
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, new_id),
+            ModelingCmd::from(mcmd::EntityClone { entity_id: old_id }),
+        )
         .await?;
 
     fix_tags_and_references(&mut new_geometry, old_id, exec_state, &args)
@@ -169,9 +175,9 @@ async fn get_old_new_child_map(
     args: &Args,
 ) -> Result<HashMap<uuid::Uuid, uuid::Uuid>> {
     // Get the old geometries entity ids.
-    let response = args
+    let response = exec_state
         .send_modeling_cmd(
-            exec_state.next_uuid(),
+            args.into(),
             ModelingCmd::from(mcmd::EntityGetAllChildUuids {
                 entity_id: old_geometry_id,
             }),
@@ -188,9 +194,9 @@ async fn get_old_new_child_map(
     };
 
     // Get the new geometries entity ids.
-    let response = args
+    let response = exec_state
         .send_modeling_cmd(
-            exec_state.next_uuid(),
+            args.into(),
             ModelingCmd::from(mcmd::EntityGetAllChildUuids {
                 entity_id: new_geometry_id,
             }),

rust/kcl-lib/src/std/csg.rs

@@ -12,7 +12,7 @@ use kittycad_modeling_cmds::{
 use super::{args::TyF64, DEFAULT_TOLERANCE};
 use crate::{
     errors::{KclError, KclErrorDetails},
-    execution::{types::RuntimeType, ExecState, KclValue, Solid},
+    execution::{types::RuntimeType, ExecState, KclValue, ModelingCmdMeta, Solid},
     std::{patterns::GeometryTrait, Args},
 };
 
@@ -50,11 +50,11 @@ pub(crate) async fn inner_union(
     }
 
     // Flush the fillets for the solids.
-    args.flush_batch_for_solids(exec_state, &solids).await?;
+    exec_state.flush_batch_for_solids((&args).into(), &solids).await?;
 
-    let result = args
+    let result = exec_state
         .send_modeling_cmd(
-            solid_out_id,
+            ModelingCmdMeta::from_args_id(&args, solid_out_id),
             ModelingCmd::from(mcmd::BooleanUnion {
                 solid_ids: solids.iter().map(|s| s.id).collect(),
                 tolerance: LengthUnit(tolerance.map(|t| t.n).unwrap_or(DEFAULT_TOLERANCE)),
@@ -115,11 +115,11 @@ pub(crate) async fn inner_intersect(
     }
 
     // Flush the fillets for the solids.
-    args.flush_batch_for_solids(exec_state, &solids).await?;
+    exec_state.flush_batch_for_solids((&args).into(), &solids).await?;
 
-    let result = args
+    let result = exec_state
         .send_modeling_cmd(
-            solid_out_id,
+            ModelingCmdMeta::from_args_id(&args, solid_out_id),
             ModelingCmd::from(mcmd::BooleanIntersection {
                 solid_ids: solids.iter().map(|s| s.id).collect(),
                 tolerance: LengthUnit(tolerance.map(|t| t.n).unwrap_or(DEFAULT_TOLERANCE)),
@@ -176,11 +176,13 @@ pub(crate) async fn inner_subtract(
 
     // Flush the fillets for the solids and the tools.
     let combined_solids = solids.iter().chain(tools.iter()).cloned().collect::<Vec<Solid>>();
-    args.flush_batch_for_solids(exec_state, &combined_solids).await?;
+    exec_state
+        .flush_batch_for_solids((&args).into(), &combined_solids)
+        .await?;
 
-    let result = args
+    let result = exec_state
         .send_modeling_cmd(
-            solid_out_id,
+            ModelingCmdMeta::from_args_id(&args, solid_out_id),
             ModelingCmd::from(mcmd::BooleanSubtract {
                 target_ids: solids.iter().map(|s| s.id).collect(),
                 tool_ids: tools.iter().map(|s| s.id).collect(),

rust/kcl-lib/src/std/edge.rs

@@ -9,7 +9,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{ArrayLen, RuntimeType},
-        ExecState, ExtrudeSurface, KclValue, TagIdentifier,
+        ExecState, ExtrudeSurface, KclValue, ModelingCmdMeta, TagIdentifier,
     },
     std::Args,
 };
@@ -35,15 +35,16 @@ async fn inner_get_opposite_edge(
     }
     let face_id = args.get_adjacent_face_to_tag(exec_state, &edge, false).await?;
 
-    let id = exec_state.next_uuid();
     let tagged_path = args.get_tag_engine_info(exec_state, &edge)?;
+    let tagged_path_id = tagged_path.id;
+    let sketch_id = tagged_path.sketch;
 
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            (&args).into(),
             ModelingCmd::from(mcmd::Solid3dGetOppositeEdge {
-                edge_id: tagged_path.id,
-                object_id: tagged_path.sketch,
+                edge_id: tagged_path_id,
+                object_id: sketch_id,
                 face_id,
             }),
         )
@@ -82,15 +83,16 @@ async fn inner_get_next_adjacent_edge(
     }
     let face_id = args.get_adjacent_face_to_tag(exec_state, &edge, false).await?;
 
-    let id = exec_state.next_uuid();
     let tagged_path = args.get_tag_engine_info(exec_state, &edge)?;
+    let tagged_path_id = tagged_path.id;
+    let sketch_id = tagged_path.sketch;
 
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            (&args).into(),
             ModelingCmd::from(mcmd::Solid3dGetNextAdjacentEdge {
-                edge_id: tagged_path.id,
-                object_id: tagged_path.sketch,
+                edge_id: tagged_path_id,
+                object_id: sketch_id,
                 face_id,
             }),
         )
@@ -138,15 +140,16 @@ async fn inner_get_previous_adjacent_edge(
     }
     let face_id = args.get_adjacent_face_to_tag(exec_state, &edge, false).await?;
 
-    let id = exec_state.next_uuid();
     let tagged_path = args.get_tag_engine_info(exec_state, &edge)?;
+    let tagged_path_id = tagged_path.id;
+    let sketch_id = tagged_path.sketch;
 
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            (&args).into(),
             ModelingCmd::from(mcmd::Solid3dGetPrevAdjacentEdge {
-                edge_id: tagged_path.id,
-                object_id: tagged_path.sketch,
+                edge_id: tagged_path_id,
+                object_id: sketch_id,
                 face_id,
             }),
         )
@@ -221,14 +224,14 @@ async fn inner_get_common_edge(
     // TODO: we likely want to be a lot more persnickety _which_ fillets we are flushing
     // but for now, we'll just flush everything.
     if let Some(ExtrudeSurface::Chamfer { .. } | ExtrudeSurface::Fillet { .. }) = first_tagged_path.surface {
-        args.ctx.engine.flush_batch(true, args.source_range).await?;
+        exec_state.flush_batch((&args).into(), true).await?;
     } else if let Some(ExtrudeSurface::Chamfer { .. } | ExtrudeSurface::Fillet { .. }) = second_tagged_path.surface {
-        args.ctx.engine.flush_batch(true, args.source_range).await?;
+        exec_state.flush_batch((&args).into(), true).await?;
     }
 
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::Solid3dGetCommonEdge {
                 object_id: first_tagged_path.sketch,
                 face_ids: [first_face_id, second_face_id],

rust/kcl-lib/src/std/extrude.rs

@@ -19,8 +19,8 @@ use super::args::TyF64;
 use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
-        types::RuntimeType, ArtifactId, ExecState, ExtrudeSurface, GeoMeta, KclValue, Path, Sketch, SketchSurface,
-        Solid,
+        types::RuntimeType, ArtifactId, ExecState, ExtrudeSurface, GeoMeta, KclValue, ModelingCmdMeta, Path, Sketch,
+        SketchSurface, Solid,
     },
     parsing::ast::types::TagNode,
     std::Args,
@@ -85,7 +85,7 @@ async fn inner_extrude(
 
     for sketch in &sketches {
         let id = exec_state.next_uuid();
-        args.batch_modeling_cmds(&sketch.build_sketch_mode_cmds(
+        let cmds = sketch.build_sketch_mode_cmds(
             exec_state,
             ModelingCmdReq {
                 cmd_id: id.into(),
@@ -96,7 +96,9 @@ async fn inner_extrude(
                     opposite: opposite.clone(),
                 }),
             },
-        ))
+        );
+        exec_state
+            .batch_modeling_cmds(ModelingCmdMeta::from_args_id(&args, id), &cmds)
             .await?;
 
         solids.push(
@@ -139,8 +141,9 @@ pub(crate) async fn do_post_extrude<'a>(
 ) -> Result<Solid, KclError> {
     // Bring the object to the front of the scene.
     // See: https://github.com/KittyCAD/modeling-app/issues/806
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            args.into(),
             ModelingCmd::from(mcmd::ObjectBringToFront { object_id: sketch.id }),
         )
         .await?;
@@ -168,9 +171,9 @@ pub(crate) async fn do_post_extrude<'a>(
         sketch.id = face.solid.sketch.id;
     }
 
-    let solid3d_info = args
+    let solid3d_info = exec_state
         .send_modeling_cmd(
-            exec_state.next_uuid(),
+            args.into(),
             ModelingCmd::from(mcmd::Solid3dGetExtrusionFaceInfo {
                 edge_id: any_edge_id,
                 object_id: sketch.id,
@@ -193,8 +196,9 @@ pub(crate) async fn do_post_extrude<'a>(
         // Getting the ids of a sectional sweep does not work well and we cannot guarantee that
         // any of these call will not just fail.
         if !sectional {
-            args.batch_modeling_cmd(
-                exec_state.next_uuid(),
+            exec_state
+                .batch_modeling_cmd(
+                    args.into(),
                     ModelingCmd::from(mcmd::Solid3dGetAdjacencyInfo {
                         object_id: sketch.id,
                         edge_id: any_edge_id,

rust/kcl-lib/src/std/fillet.rs

@@ -10,7 +10,8 @@ use super::{args::TyF64, DEFAULT_TOLERANCE};
 use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
-        types::RuntimeType, EdgeCut, ExecState, ExtrudeSurface, FilletSurface, GeoMeta, KclValue, Solid, TagIdentifier,
+        types::RuntimeType, EdgeCut, ExecState, ExtrudeSurface, FilletSurface, GeoMeta, KclValue, ModelingCmdMeta,
+        Solid, TagIdentifier,
     },
     parsing::ast::types::TagNode,
     std::Args,
@@ -111,8 +112,9 @@ async fn inner_fillet(
     for _ in 0..num_extra_ids {
         extra_face_ids.push(exec_state.next_uuid());
     }
-    args.batch_end_cmd(
-        id,
+    exec_state
+        .batch_end_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::Solid3dFilletEdge {
                 edge_id: None,
                 edge_ids: edge_ids.clone(),

rust/kcl-lib/src/std/helix.rs

@@ -9,7 +9,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{PrimitiveType, RuntimeType},
-        ExecState, Helix as HelixValue, KclValue, Solid,
+        ExecState, Helix as HelixValue, KclValue, ModelingCmdMeta, Solid,
     },
     std::{axis_or_reference::Axis3dOrEdgeReference, Args},
 };
@@ -124,8 +124,9 @@ async fn inner_helix(
     }
 
     if let Some(cylinder) = cylinder {
-        args.batch_modeling_cmd(
-            id,
+        exec_state
+            .batch_modeling_cmd(
+                ModelingCmdMeta::from_args_id(&args, id),
                 ModelingCmd::from(mcmd::EntityMakeHelix {
                     cylinder_id: cylinder.id,
                     is_clockwise: !helix_result.ccw,
@@ -146,8 +147,9 @@ async fn inner_helix(
                     )));
                 };
 
-                args.batch_modeling_cmd(
-                    id,
+                exec_state
+                    .batch_modeling_cmd(
+                        ModelingCmdMeta::from_args_id(&args, id),
                         ModelingCmd::from(mcmd::EntityMakeHelixFromParams {
                             radius: LengthUnit(radius.to_mm()),
                             is_clockwise: !helix_result.ccw,
@@ -171,8 +173,9 @@ async fn inner_helix(
             Axis3dOrEdgeReference::Edge(edge) => {
                 let edge_id = edge.get_engine_id(exec_state, &args)?;
 
-                args.batch_modeling_cmd(
-                    id,
+                exec_state
+                    .batch_modeling_cmd(
+                        ModelingCmdMeta::from_args_id(&args, id),
                         ModelingCmd::from(mcmd::EntityMakeHelixFromEdge {
                             radius: LengthUnit(radius.to_mm()),
                             is_clockwise: !helix_result.ccw,

rust/kcl-lib/src/std/loft.rs

@@ -11,7 +11,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{NumericType, RuntimeType},
-        ExecState, KclValue, Sketch, Solid,
+        ExecState, KclValue, ModelingCmdMeta, Sketch, Solid,
     },
     parsing::ast::types::TagNode,
     std::{extrude::do_post_extrude, Args},
@@ -77,8 +77,9 @@ async fn inner_loft(
     }
 
     let id = exec_state.next_uuid();
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::Loft {
                 section_ids: sketches.iter().map(|group| group.id).collect(),
                 base_curve_index,

rust/kcl-lib/src/std/mirror.rs

@@ -52,8 +52,9 @@ async fn inner_mirror_2d(
 
     match axis {
         Axis2dOrEdgeReference::Axis { direction, origin } => {
-            args.batch_modeling_cmd(
-                exec_state.next_uuid(),
+            exec_state
+                .batch_modeling_cmd(
+                    (&args).into(),
                     ModelingCmd::from(mcmd::EntityMirror {
                         ids: starting_sketches.iter().map(|sketch| sketch.id).collect(),
                         axis: Point3d {
@@ -73,8 +74,9 @@ async fn inner_mirror_2d(
         Axis2dOrEdgeReference::Edge(edge) => {
             let edge_id = edge.get_engine_id(exec_state, &args)?;
 
-            args.batch_modeling_cmd(
-                exec_state.next_uuid(),
+            exec_state
+                .batch_modeling_cmd(
+                    (&args).into(),
                     ModelingCmd::from(mcmd::EntityMirrorAcrossEdge {
                         ids: starting_sketches.iter().map(|sketch| sketch.id).collect(),
                         edge_id,
@@ -90,9 +92,9 @@ async fn inner_mirror_2d(
     // using the IDs we already have.
     // We only do this with mirrors because otherwise it is a waste of a websocket call.
     for sketch in &mut starting_sketches {
-        let response = args
+        let response = exec_state
             .send_modeling_cmd(
-                exec_state.next_uuid(),
+                (&args).into(),
                 ModelingCmd::from(mcmd::EntityGetAllChildUuids { entity_id: sketch.id }),
             )
             .await?;

rust/kcl-lib/src/std/patterns.rs

@@ -149,12 +149,11 @@ async fn send_pattern_transform<T: GeometryTrait>(
     exec_state: &mut ExecState,
     args: &Args,
 ) -> Result<Vec<T>, KclError> {
-    let id = exec_state.next_uuid();
     let extra_instances = transforms.len();
 
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            args.into(),
             ModelingCmd::from(mcmd::EntityLinearPatternTransform {
                 entity_id: if use_original { solid.original_id() } else { solid.id() },
                 transform: Default::default(),
@@ -443,7 +442,7 @@ impl GeometryTrait for Solid {
     }
 
     async fn flush_batch(args: &Args, exec_state: &mut ExecState, solid_set: &Self::Set) -> Result<(), KclError> {
-        args.flush_batch_for_solids(exec_state, solid_set).await
+        exec_state.flush_batch_for_solids(args.into(), solid_set).await
     }
 }
 
@@ -874,7 +873,7 @@ async fn inner_pattern_circular_3d(
     // Flush the batch for our fillets/chamfers if there are any.
     // If we do not flush these, then you won't be able to pattern something with fillets.
     // Flush just the fillets/chamfers that apply to these solids.
-    args.flush_batch_for_solids(exec_state, &solids).await?;
+    exec_state.flush_batch_for_solids((&args).into(), &solids).await?;
 
     let starting_solids = solids;
 
@@ -919,7 +918,6 @@ async fn pattern_circular(
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Geometries, KclError> {
-    let id = exec_state.next_uuid();
     let num_repetitions = match data.repetitions() {
         RepetitionsNeeded::More(n) => n,
         RepetitionsNeeded::None => {
@@ -934,9 +932,9 @@ async fn pattern_circular(
     };
 
     let center = data.center_mm();
-    let resp = args
+    let resp = exec_state
         .send_modeling_cmd(
-            id,
+            (&args).into(),
             ModelingCmd::from(mcmd::EntityCircularPattern {
                 axis: kcmc::shared::Point3d::from(data.axis()),
                 entity_id: if data.use_original() {

rust/kcl-lib/src/std/planes.rs

@@ -6,7 +6,7 @@ use kittycad_modeling_cmds as kcmc;
 use super::{args::TyF64, sketch::PlaneData};
 use crate::{
     errors::KclError,
-    execution::{types::RuntimeType, ExecState, KclValue, Plane, PlaneType},
+    execution::{types::RuntimeType, ExecState, KclValue, ModelingCmdMeta, Plane, PlaneType},
     std::Args,
 };
 
@@ -49,8 +49,10 @@ async fn make_offset_plane_in_engine(plane: &Plane, exec_state: &mut ExecState,
         a: 0.3,
     };
 
-    args.batch_modeling_cmd(
-        plane.id,
+    let meta = ModelingCmdMeta::from_args_id(args, plane.id);
+    exec_state
+        .batch_modeling_cmd(
+            meta,
             ModelingCmd::from(mcmd::MakePlane {
                 clobber: false,
                 origin: plane.info.origin.into(),
@@ -63,8 +65,9 @@ async fn make_offset_plane_in_engine(plane: &Plane, exec_state: &mut ExecState,
         .await?;
 
     // Set the color.
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            args.into(),
             ModelingCmd::from(mcmd::PlaneSetColor {
                 color,
                 plane_id: plane.id,

rust/kcl-lib/src/std/revolve.rs

@@ -14,7 +14,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{NumericType, PrimitiveType, RuntimeType},
-        ExecState, KclValue, Sketch, Solid,
+        ExecState, KclValue, ModelingCmdMeta, Sketch, Solid,
     },
     parsing::ast::types::TagNode,
     std::{axis_or_reference::Axis2dOrEdgeReference, extrude::do_post_extrude, Args},
@@ -137,8 +137,9 @@ async fn inner_revolve(
 
         let direction = match &axis {
             Axis2dOrEdgeReference::Axis { direction, origin } => {
-                args.batch_modeling_cmd(
-                    id,
+                exec_state
+                    .batch_modeling_cmd(
+                        ModelingCmdMeta::from_args_id(&args, id),
                         ModelingCmd::from(mcmd::Revolve {
                             angle,
                             target: sketch.id.into(),
@@ -162,8 +163,9 @@ async fn inner_revolve(
             }
             Axis2dOrEdgeReference::Edge(edge) => {
                 let edge_id = edge.get_engine_id(exec_state, &args)?;
-                args.batch_modeling_cmd(
-                    id,
+                exec_state
+                    .batch_modeling_cmd(
+                        ModelingCmdMeta::from_args_id(&args, id),
                         ModelingCmd::from(mcmd::RevolveAboutEdge {
                             angle,
                             target: sketch.id.into(),

rust/kcl-lib/src/std/shapes.rs

@@ -20,7 +20,7 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{RuntimeType, UnitLen},
-        BasePath, ExecState, GeoMeta, KclValue, Path, Sketch, SketchSurface,
+        BasePath, ExecState, GeoMeta, KclValue, ModelingCmdMeta, Path, Sketch, SketchSurface,
     },
     parsing::ast::types::TagNode,
     std::{
@@ -82,8 +82,9 @@ async fn inner_circle(
 
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Arc {
@@ -120,7 +121,11 @@ async fn inner_circle(
 
     new_sketch.paths.push(current_path);
 
-    args.batch_modeling_cmd(id, ModelingCmd::from(mcmd::ClosePath { path_id: new_sketch.id }))
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
+            ModelingCmd::from(mcmd::ClosePath { path_id: new_sketch.id }),
+        )
         .await?;
 
     Ok(new_sketch)
@@ -180,8 +185,9 @@ async fn inner_circle_three_point(
 
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Arc {
@@ -219,7 +225,11 @@ async fn inner_circle_three_point(
 
     new_sketch.paths.push(current_path);
 
-    args.batch_modeling_cmd(id, ModelingCmd::from(mcmd::ClosePath { path_id: new_sketch.id }))
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
+            ModelingCmd::from(mcmd::ClosePath { path_id: new_sketch.id }),
+        )
         .await?;
 
     Ok(new_sketch)
@@ -326,8 +336,9 @@ async fn inner_polygon(
         let from = sketch.current_pen_position()?;
         let id = exec_state.next_uuid();
 
-        args.batch_modeling_cmd(
-            id,
+        exec_state
+            .batch_modeling_cmd(
+                ModelingCmdMeta::from_args_id(&args, id),
                 ModelingCmd::from(mcmd::ExtendPath {
                     path: sketch.id.into(),
                     segment: PathSegment::Line {
@@ -360,8 +371,9 @@ async fn inner_polygon(
     let from = sketch.current_pen_position()?;
     let close_id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
-        close_id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, close_id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Line {
@@ -389,8 +401,9 @@ async fn inner_polygon(
 
     sketch.paths.push(current_path);
 
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            (&args).into(),
             ModelingCmd::from(mcmd::ClosePath { path_id: sketch.id }),
         )
         .await?;

rust/kcl-lib/src/std/shell.rs

@@ -53,7 +53,9 @@ async fn inner_shell(
     for solid in &solids {
         // Flush the batch for our fillets/chamfers if there are any.
         // If we do not do these for sketch on face, things will fail with face does not exist.
-        args.flush_batch_for_solids(exec_state, &[solid.clone()]).await?;
+        exec_state
+            .flush_batch_for_solids((&args).into(), &[solid.clone()])
+            .await?;
 
         for tag in &faces {
             let extrude_plane_id = tag.get_face_id(solid, exec_state, &args, false).await?;
@@ -78,8 +80,9 @@ async fn inner_shell(
         )));
     }
 
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            (&args).into(),
             ModelingCmd::from(mcmd::Solid3dShellFace {
                 hollow: false,
                 face_ids,
@@ -109,10 +112,13 @@ async fn inner_hollow(
 ) -> Result<Box<Solid>, KclError> {
     // Flush the batch for our fillets/chamfers if there are any.
     // If we do not do these for sketch on face, things will fail with face does not exist.
-    args.flush_batch_for_solids(exec_state, &[(*solid).clone()]).await?;
+    exec_state
+        .flush_batch_for_solids((&args).into(), &[(*solid).clone()])
+        .await?;
 
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            (&args).into(),
             ModelingCmd::from(mcmd::Solid3dShellFace {
                 hollow: true,
                 face_ids: Vec::new(), // This is empty because we want to hollow the entire object.

rust/kcl-lib/src/std/sketch.rs

@@ -18,8 +18,8 @@ use crate::{
     errors::{KclError, KclErrorDetails},
     execution::{
         types::{ArrayLen, NumericType, PrimitiveType, RuntimeType, UnitLen},
-        BasePath, ExecState, Face, GeoMeta, KclValue, Path, Plane, PlaneInfo, Point2d, Sketch, SketchSurface, Solid,
-        TagEngineInfo, TagIdentifier,
+        BasePath, ExecState, Face, GeoMeta, KclValue, ModelingCmdMeta, Path, Plane, PlaneInfo, Point2d, Sketch,
+        SketchSurface, Solid, TagEngineInfo, TagIdentifier,
     },
     parsing::ast::types::TagNode,
     std::{
@@ -133,8 +133,9 @@ async fn inner_involute_circular(
 ) -> Result<Sketch, KclError> {
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::CircularInvolute {
@@ -284,8 +285,9 @@ async fn straight_line(
     };
 
     let id = exec_state.next_uuid();
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Line {
@@ -507,8 +509,9 @@ async fn inner_angled_line_length(
 
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Line {
@@ -874,8 +877,9 @@ async fn make_sketch_plane_from_orientation(
     let clobber = false;
     let size = LengthUnit(60.0);
     let hide = Some(true);
-    args.batch_modeling_cmd(
-        plane.id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(args, plane.id),
             ModelingCmd::from(mcmd::MakePlane {
                 clobber,
                 origin: plane.info.origin.into(),
@@ -917,14 +921,16 @@ pub(crate) async fn inner_start_profile(
         SketchSurface::Face(face) => {
             // Flush the batch for our fillets/chamfers if there are any.
             // If we do not do these for sketch on face, things will fail with face does not exist.
-            args.flush_batch_for_solids(exec_state, &[(*face.solid).clone()])
+            exec_state
+                .flush_batch_for_solids((&args).into(), &[(*face.solid).clone()])
                 .await?;
         }
         SketchSurface::Plane(plane) if !plane.is_standard() => {
             // Hide whatever plane we are sketching on.
             // This is especially helpful for offset planes, which would be visible otherwise.
-            args.batch_end_cmd(
-                exec_state.next_uuid(),
+            exec_state
+                .batch_end_cmd(
+                    (&args).into(),
                     ModelingCmd::from(mcmd::ObjectVisible {
                         object_id: plane.id,
                         hidden: true,
@@ -938,7 +944,11 @@ pub(crate) async fn inner_start_profile(
     let enable_sketch_id = exec_state.next_uuid();
     let path_id = exec_state.next_uuid();
     let move_pen_id = exec_state.next_uuid();
-    args.batch_modeling_cmds(&[
+    let disable_sketch_id = exec_state.next_uuid();
+    exec_state
+        .batch_modeling_cmds(
+            (&args).into(),
+            &[
                 // Enter sketch mode on the surface.
                 // We call this here so you can reuse the sketch surface for multiple sketches.
                 ModelingCmdReq {
@@ -970,9 +980,10 @@ pub(crate) async fn inner_start_profile(
                 },
                 ModelingCmdReq {
                     cmd: ModelingCmd::SketchModeDisable(mcmd::SketchModeDisable::default()),
-            cmd_id: exec_state.next_uuid().into(),
+                    cmd_id: disable_sketch_id.into(),
                 },
-    ])
+            ],
+        )
         .await?;
 
     // Convert to the units of the module.  This is what the frontend expects.
@@ -1077,7 +1088,11 @@ pub(crate) async fn inner_close(
 
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(id, ModelingCmd::from(mcmd::ClosePath { path_id: sketch.id }))
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(&args, id),
+            ModelingCmd::from(mcmd::ClosePath { path_id: sketch.id }),
+        )
         .await?;
 
     let current_path = Path::ToPoint {
@@ -1178,8 +1193,9 @@ pub async fn absolute_arc(
     tag: Option<TagNode>,
 ) -> Result<Sketch, KclError> {
     // The start point is taken from the path you are extending.
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::ArcTo {
@@ -1252,8 +1268,9 @@ pub async fn relative_arc(
     }
     let ccw = a_start < a_end;
 
-    args.batch_modeling_cmd(
-        id,
+    exec_state
+        .batch_modeling_cmd(
+            ModelingCmdMeta::from_args_id(args, id),
             ModelingCmd::from(mcmd::ExtendPath {
                 path: sketch.id.into(),
                 segment: PathSegment::Arc {
@@ -1421,8 +1438,9 @@ async fn inner_tangential_arc_radius_angle(
                 radius.to_length_units(from.units),
             );
 
-            args.batch_modeling_cmd(
-                id,
+            exec_state
+                .batch_modeling_cmd(
+                    ModelingCmdMeta::from_args_id(&args, id),
                     ModelingCmd::from(mcmd::ExtendPath {
                         path: sketch.id.into(),
                         segment: PathSegment::TangentialArc {
@@ -1521,7 +1539,9 @@ async fn inner_tangential_arc_to_point(
         point
     };
     let id = exec_state.next_uuid();
-    args.batch_modeling_cmd(id, tan_arc_to(&sketch, delta)).await?;
+    exec_state
+        .batch_modeling_cmd(ModelingCmdMeta::from_args_id(&args, id), tan_arc_to(&sketch, delta))
+        .await?;
 
     let current_path = Path::TangentialArcTo {
         base: BasePath {
@@ -1609,8 +1629,9 @@ async fn inner_bezier_curve(
                 from.y + end[1].to_length_units(from.units),
             ];
 
-            args.batch_modeling_cmd(
-                id,
+            exec_state
+                .batch_modeling_cmd(
+                    ModelingCmdMeta::from_args_id(&args, id),
                     ModelingCmd::from(mcmd::ExtendPath {
                         path: sketch.id.into(),
                         segment: PathSegment::Bezier {
@@ -1627,8 +1648,9 @@ async fn inner_bezier_curve(
         // Absolute
         (None, None, None, Some(control1), Some(control2), Some(end)) => {
             let to = [end[0].to_length_units(from.units), end[1].to_length_units(from.units)];
-            args.batch_modeling_cmd(
-                id,
+            exec_state
+                .batch_modeling_cmd(
+                    ModelingCmdMeta::from_args_id(&args, id),
                     ModelingCmd::from(mcmd::ExtendPath {
                         path: sketch.id.into(),
                         segment: PathSegment::Bezier {
@@ -1699,8 +1721,9 @@ async fn inner_subtract_2d(
     args: Args,
 ) -> Result<Sketch, KclError> {
     for hole_sketch in tool {
-        args.batch_modeling_cmd(
-            exec_state.next_uuid(),
+        exec_state
+            .batch_modeling_cmd(
+                ModelingCmdMeta::from(&args),
                 ModelingCmd::from(mcmd::Solid2dAddHole {
                     object_id: sketch.id,
                     hole_id: hole_sketch.id,
@@ -1710,8 +1733,9 @@ async fn inner_subtract_2d(
 
         // suggestion (mike)
         // we also hide the source hole since its essentially "consumed" by this operation
-        args.batch_modeling_cmd(
-            exec_state.next_uuid(),
+        exec_state
+            .batch_modeling_cmd(
+                ModelingCmdMeta::from(&args),
                 ModelingCmd::from(mcmd::ObjectVisible {
                     object_id: hole_sketch.id,
                     hidden: true,

rust/kcl-lib/src/std/sweep.rs

@@ -11,7 +11,7 @@ use crate::{
     errors::KclError,
     execution::{
         types::{NumericType, RuntimeType},
-        ExecState, Helix, KclValue, Sketch, Solid,
+        ExecState, Helix, KclValue, ModelingCmdMeta, Sketch, Solid,
     },
     parsing::ast::types::TagNode,
     std::{extrude::do_post_extrude, Args},
@@ -86,8 +86,9 @@ async fn inner_sweep(
     let mut solids = Vec::new();
     for sketch in &sketches {
         let id = exec_state.next_uuid();
-        args.batch_modeling_cmd(
-            id,
+        exec_state
+            .batch_modeling_cmd(
+                ModelingCmdMeta::from_args_id(&args, id),
                 ModelingCmd::from(mcmd::Sweep {
                     target: sketch.id.into(),
                     trajectory,
@@ -117,8 +118,9 @@ async fn inner_sweep(
     }
 
     // Hide the artifact from the sketch or helix.
-    args.batch_modeling_cmd(
-        exec_state.next_uuid(),
+    exec_state
+        .batch_modeling_cmd(
+            (&args).into(),
             ModelingCmd::from(mcmd::ObjectVisible {
                 object_id: trajectory.into(),
                 hidden: true,

rust/kcl-lib/src/std/transform.rs

@@ -68,15 +68,14 @@ async fn inner_scale(
     // If we have a solid, flush the fillets and chamfers.
     // Only transforms needs this, it is very odd, see: https://github.com/KittyCAD/modeling-app/issues/5880
     if let SolidOrSketchOrImportedGeometry::SolidSet(solids) = &objects {
-        args.flush_batch_for_solids(exec_state, solids).await?;
+        exec_state.flush_batch_for_solids((&args).into(), solids).await?;
     }
 
     let mut objects = objects.clone();
     for object_id in objects.ids(&args.ctx).await? {
-        let id = exec_state.next_uuid();
-
-        args.batch_modeling_cmd(
-            id,
+        exec_state
+            .batch_modeling_cmd(
+                (&args).into(),
                 ModelingCmd::from(mcmd::SetObjectTransform {
                     object_id,
                     transforms: vec![shared::ComponentTransform {
@@ -141,15 +140,14 @@ async fn inner_translate(
     // If we have a solid, flush the fillets and chamfers.
     // Only transforms needs this, it is very odd, see: https://github.com/KittyCAD/modeling-app/issues/5880
     if let SolidOrSketchOrImportedGeometry::SolidSet(solids) = &objects {
-        args.flush_batch_for_solids(exec_state, solids).await?;
+        exec_state.flush_batch_for_solids((&args).into(), solids).await?;
     }
 
     let mut objects = objects.clone();
     for object_id in objects.ids(&args.ctx).await? {
-        let id = exec_state.next_uuid();
-
-        args.batch_modeling_cmd(
-            id,
+        exec_state
+            .batch_modeling_cmd(
+                (&args).into(),
                 ModelingCmd::from(mcmd::SetObjectTransform {
                     object_id,
                     transforms: vec![shared::ComponentTransform {
@@ -313,16 +311,15 @@ async fn inner_rotate(
     // If we have a solid, flush the fillets and chamfers.
     // Only transforms needs this, it is very odd, see: https://github.com/KittyCAD/modeling-app/issues/5880
     if let SolidOrSketchOrImportedGeometry::SolidSet(solids) = &objects {
-        args.flush_batch_for_solids(exec_state, solids).await?;
+        exec_state.flush_batch_for_solids((&args).into(), solids).await?;
     }
 
     let mut objects = objects.clone();
     for object_id in objects.ids(&args.ctx).await? {
-        let id = exec_state.next_uuid();
-
         if let (Some(axis), Some(angle)) = (&axis, angle) {
-            args.batch_modeling_cmd(
-                id,
+            exec_state
+                .batch_modeling_cmd(
+                    (&args).into(),
                     ModelingCmd::from(mcmd::SetObjectTransform {
                         object_id,
                         transforms: vec![shared::ComponentTransform {
@@ -345,8 +342,9 @@ async fn inner_rotate(
                 .await?;
         } else {
             // Do roll, pitch, and yaw.
-            args.batch_modeling_cmd(
-                id,
+            exec_state
+                .batch_modeling_cmd(
+                    (&args).into(),
                     ModelingCmd::from(mcmd::SetObjectTransform {
                         object_id,
                         transforms: vec![shared::ComponentTransform {

rust/kcl-lib/tests/add_lots/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands add_lots.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/add_lots/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/add_lots/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed add_lots.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/add_lots/input.kcl": [
     {
       "type": "GroupBegin",
       "group": {
@@ -208,6 +209,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -413,6 +417,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -615,6 +622,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -814,6 +824,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1010,6 +1023,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1203,6 +1219,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1393,6 +1412,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1580,6 +1602,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1764,6 +1789,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -1945,6 +1973,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2123,6 +2154,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2298,6 +2332,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2470,6 +2507,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2639,6 +2679,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2805,6 +2848,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -2968,6 +3014,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3128,6 +3177,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3285,6 +3337,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3439,6 +3494,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3590,6 +3648,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3738,6 +3799,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -3883,6 +3947,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4025,6 +4092,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4164,6 +4234,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4300,6 +4373,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4433,6 +4509,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4563,6 +4642,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4690,6 +4772,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4814,6 +4899,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -4935,6 +5023,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5053,6 +5144,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5168,6 +5262,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5280,6 +5377,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5389,6 +5489,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5495,6 +5598,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5598,6 +5704,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5698,6 +5807,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5795,6 +5907,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5889,6 +6004,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -5980,6 +6098,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6068,6 +6189,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6153,6 +6277,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6235,6 +6362,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6314,6 +6444,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6390,6 +6523,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6463,6 +6599,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6533,6 +6672,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6600,6 +6742,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6664,6 +6809,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6725,6 +6873,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6783,6 +6934,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6838,6 +6992,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6890,6 +7047,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6939,6 +7099,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -6985,6 +7148,9 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -7028,172 +7194,19 @@ description: Operations executed add_lots.kcl
       },
       "sourceRange": []
     },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
     {
       "type": "GroupEnd"
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/angled_line/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands angled_line.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/angled_line/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands angled_line.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands angled_line.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -217,14 +192,6 @@ description: Artifact commands angled_line.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -236,9 +203,8 @@ description: Artifact commands angled_line.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -249,5 +215,26 @@ description: Artifact commands angled_line.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/angled_line/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed angled_line.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/angled_line/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -84,4 +85,16 @@ description: Operations executed angled_line.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/any_type/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands any_type.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/any_type/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/any_type/ops.snap

@@ -2,7 +2,207 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed any_type.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/any_type/input.kcl": [
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "FunctionCall",
+        "name": "id",
+        "functionSourceRange": [],
+        "unlabeledArg": {
+          "value": {
+            "type": "Number",
+            "value": 1.0,
+            "ty": {
+              "type": "Default",
+              "len": {
+                "type": "Mm"
+              },
+              "angle": {
+                "type": "Degrees"
+              }
+            }
+          },
+          "sourceRange": []
+        },
+        "labeledArgs": {}
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 3
+          },
+          {
+            "type": "VariableDeclarationDeclaration"
+          },
+          {
+            "type": "VariableDeclarationInit"
+          }
+        ]
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "GroupEnd"
+    },
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "FunctionCall",
+        "name": "id",
+        "functionSourceRange": [],
+        "unlabeledArg": {
+          "value": {
+            "type": "String",
+            "value": "a"
+          },
+          "sourceRange": []
+        },
+        "labeledArgs": {}
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 4
+          },
+          {
+            "type": "VariableDeclarationDeclaration"
+          },
+          {
+            "type": "VariableDeclarationInit"
+          }
+        ]
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "GroupEnd"
+    },
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "FunctionCall",
+        "name": "singleton",
+        "functionSourceRange": [],
+        "unlabeledArg": {
+          "value": {
+            "type": "Number",
+            "value": 1.0,
+            "ty": {
+              "type": "Default",
+              "len": {
+                "type": "Mm"
+              },
+              "angle": {
+                "type": "Degrees"
+              }
+            }
+          },
+          "sourceRange": []
+        },
+        "labeledArgs": {}
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 5
+          },
+          {
+            "type": "VariableDeclarationDeclaration"
+          },
+          {
+            "type": "VariableDeclarationInit"
+          }
+        ]
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "GroupEnd"
+    },
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "FunctionCall",
+        "name": "len",
+        "functionSourceRange": [],
+        "unlabeledArg": {
+          "value": {
+            "type": "Array",
+            "value": []
+          },
+          "sourceRange": []
+        },
+        "labeledArgs": {}
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 6
+          },
+          {
+            "type": "VariableDeclarationDeclaration"
+          },
+          {
+            "type": "VariableDeclarationInit"
+          }
+        ]
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "GroupEnd"
+    },
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "FunctionCall",
+        "name": "len",
+        "functionSourceRange": [],
+        "unlabeledArg": {
+          "value": {
+            "type": "Array",
+            "value": [
+              {
+                "type": "Number",
+                "value": 1.0,
+                "ty": {
+                  "type": "Default",
+                  "len": {
+                    "type": "Mm"
+                  },
+                  "angle": {
+                    "type": "Degrees"
+                  }
+                }
+              }
+            ]
+          },
+          "sourceRange": []
+        },
+        "labeledArgs": {}
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 7
+          },
+          {
+            "type": "VariableDeclarationDeclaration"
+          },
+          {
+            "type": "VariableDeclarationInit"
+          }
+        ]
+      },
+      "sourceRange": []
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -70,209 +270,22 @@ description: Operations executed any_type.kcl
       },
       "sourceRange": []
     },
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "FunctionCall",
-      "name": "id",
-      "functionSourceRange": [],
-      "unlabeledArg": {
-        "value": {
-          "type": "Number",
-          "value": 1.0,
-          "ty": {
-            "type": "Default",
-            "len": {
-              "type": "Mm"
-            },
-            "angle": {
-              "type": "Degrees"
-            }
-          }
-        },
-        "sourceRange": []
-      },
-      "labeledArgs": {}
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 3
-        },
-        {
-          "type": "VariableDeclarationDeclaration"
-        },
-        {
-          "type": "VariableDeclarationInit"
-        }
-      ]
-    },
-    "sourceRange": []
-  },
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "FunctionCall",
-      "name": "id",
-      "functionSourceRange": [],
-      "unlabeledArg": {
-        "value": {
-          "type": "String",
-          "value": "a"
-        },
-        "sourceRange": []
-      },
-      "labeledArgs": {}
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 4
-        },
-        {
-          "type": "VariableDeclarationDeclaration"
-        },
-        {
-          "type": "VariableDeclarationInit"
-        }
-      ]
-    },
-    "sourceRange": []
-  },
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "FunctionCall",
-      "name": "singleton",
-      "functionSourceRange": [],
-      "unlabeledArg": {
-        "value": {
-          "type": "Number",
-          "value": 1.0,
-          "ty": {
-            "type": "Default",
-            "len": {
-              "type": "Mm"
-            },
-            "angle": {
-              "type": "Degrees"
-            }
-          }
-        },
-        "sourceRange": []
-      },
-      "labeledArgs": {}
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 5
-        },
-        {
-          "type": "VariableDeclarationDeclaration"
-        },
-        {
-          "type": "VariableDeclarationInit"
-        }
-      ]
-    },
-    "sourceRange": []
-  },
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "FunctionCall",
-      "name": "len",
-      "functionSourceRange": [],
-      "unlabeledArg": {
-        "value": {
-          "type": "Array",
-          "value": []
-        },
-        "sourceRange": []
-      },
-      "labeledArgs": {}
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 6
-        },
-        {
-          "type": "VariableDeclarationDeclaration"
-        },
-        {
-          "type": "VariableDeclarationInit"
-        }
-      ]
-    },
-    "sourceRange": []
-  },
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "FunctionCall",
-      "name": "len",
-      "functionSourceRange": [],
-      "unlabeledArg": {
-        "value": {
-          "type": "Array",
-          "value": [
-            {
-              "type": "Number",
-              "value": 1.0,
-              "ty": {
-                "type": "Default",
-                "len": {
-                  "type": "Mm"
-                },
-                "angle": {
-                  "type": "Degrees"
-                }
-              }
-            }
-          ]
-        },
-        "sourceRange": []
-      },
-      "labeledArgs": {}
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 7
-        },
-        {
-          "type": "VariableDeclarationDeclaration"
-        },
-        {
-          "type": "VariableDeclarationInit"
-        }
-      ]
-    },
-    "sourceRange": []
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
-  {
-    "type": "GroupEnd"
-  },
     {
       "type": "GroupEnd"
     },
     {
       "type": "GroupEnd"
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/argument_error/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands argument_error.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/argument_error/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/argument_error/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed argument_error.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/argument_error/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_elem_pop.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_elem_pop/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_elem_pop.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_elem_pop/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop_empty_fail/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_elem_pop_empty_fail.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_elem_pop_empty_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop_empty_fail/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_elem_pop_empty_fail.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_elem_pop_empty_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop_fail/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_elem_pop_fail.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_elem_pop_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_pop_fail/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_elem_pop_fail.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_elem_pop_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_push/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_elem_push.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_elem_push/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_push/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_elem_push.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_elem_push/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_push_fail/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_elem_push_fail.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_elem_push_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_elem_push_fail/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_elem_push_fail.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_elem_push_fail/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_index_oob/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_index_oob.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_index_oob/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_index_oob/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_index_oob.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_index_oob/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_push_item_wrong_type/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_push_item_wrong_type.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_push_item_wrong_type/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_push_item_wrong_type/ops.snap

@@ -2,4 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_push_item_wrong_type.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_push_item_wrong_type/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_expr/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_range_expr.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_range_expr/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_expr/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_range_expr.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_range_expr/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_mismatch_units/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_range_mismatch_units.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_range_mismatch_units/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_mismatch_units/ops.snap

@@ -2,4 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_range_mismatch_units.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_range_mismatch_units/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_negative_expr/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_range_negative_expr.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_range_negative_expr/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_negative_expr/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_range_negative_expr.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_range_negative_expr/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_with_units/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands array_range_with_units.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/array_range_with_units/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/array_range_with_units/ops.snap

@@ -2,4 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed array_range_with_units.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/array_range_with_units/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code1/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands artifact_graph_example_code1.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code1/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands artifact_graph_example_code1.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -200,6 +175,13 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -212,14 +194,7 @@ description: Artifact commands artifact_graph_example_code1.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_adjacency_info",
+        "type": "solid3d_get_extrusion_face_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -228,7 +203,7 @@ description: Artifact commands artifact_graph_example_code1.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_adjacency_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -262,6 +237,13 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "planar_normal": null
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -282,13 +264,6 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -371,14 +346,6 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -390,9 +357,8 @@ description: Artifact commands artifact_graph_example_code1.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -403,5 +369,26 @@ description: Artifact commands artifact_graph_example_code1.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code1/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed artifact_graph_example_code1.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code1/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -235,4 +236,16 @@ description: Operations executed artifact_graph_example_code1.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code_no_3d/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands artifact_graph_example_code_no_3d.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code_no_3d/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands artifact_graph_example_code_no_3d.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands artifact_graph_example_code_no_3d.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -214,6 +189,13 @@ description: Artifact commands artifact_graph_example_code_no_3d.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -234,13 +216,6 @@ description: Artifact commands artifact_graph_example_code_no_3d.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -292,4 +267,16 @@ description: Artifact commands artifact_graph_example_code_no_3d.kcl
         }
       }
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code_no_3d/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed artifact_graph_example_code_no_3d.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code_no_3d/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -65,4 +66,16 @@ description: Operations executed artifact_graph_example_code_no_3d.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code_offset_planes/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands artifact_graph_example_code_offset_planes.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code_offset_planes/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -146,6 +121,15 @@ description: Artifact commands artifact_graph_example_code_offset_planes.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "object_visible",
+        "object_id": "[uuid]",
+        "hidden": true
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -162,6 +146,13 @@ description: Artifact commands artifact_graph_example_code_offset_planes.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -175,15 +166,6 @@ description: Artifact commands artifact_graph_example_code_offset_planes.kcl
         }
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -191,13 +173,6 @@ description: Artifact commands artifact_graph_example_code_offset_planes.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -215,4 +190,16 @@ description: Artifact commands artifact_graph_example_code_offset_planes.kcl
         }
       }
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_example_code_offset_planes/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed artifact_graph_example_code_offset_planes.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/artifact_graph_example_code_offset_planes/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "offsetPlane",
@@ -166,4 +167,16 @@ description: Operations executed artifact_graph_example_code_offset_planes.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_sketch_on_face_etc/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/artifact_graph_sketch_on_face_etc/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,14 +177,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_adjacency_info",
+        "type": "solid3d_get_extrusion_face_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -211,7 +186,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_adjacency_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -228,6 +203,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "planar_normal": null
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -248,13 +230,6 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -337,6 +312,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -349,14 +331,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_adjacency_info",
+        "type": "solid3d_get_extrusion_face_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -365,7 +340,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_adjacency_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -382,6 +357,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "planar_normal": null
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -402,13 +384,6 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -491,6 +466,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -503,14 +485,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_adjacency_info",
+        "type": "solid3d_get_extrusion_face_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -519,7 +494,7 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_adjacency_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -536,6 +511,13 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "planar_normal": null
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -556,13 +538,6 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -645,14 +620,6 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -664,9 +631,8 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -677,5 +643,26 @@ description: Artifact commands artifact_graph_sketch_on_face_etc.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/artifact_graph_sketch_on_face_etc/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed artifact_graph_sketch_on_face_etc.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/artifact_graph_sketch_on_face_etc/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -343,4 +344,16 @@ description: Operations executed artifact_graph_sketch_on_face_etc.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/ascription_unknown_type/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands ascription_unknown_type.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/ascription_unknown_type/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/ascription_unknown_type/ops.snap

@@ -2,4 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed ascription_unknown_type.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/ascription_unknown_type/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/assembly_mixed_units_cubes/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands assembly_mixed_units_cubes.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/cube-inches.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -200,14 +175,6 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -219,9 +186,8 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -233,6 +199,17 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "edge_id": "[uuid]"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
+      }
+    }
+  ],
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/cube-mm.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -274,6 +251,13 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -294,13 +278,6 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -404,14 +381,6 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -423,9 +392,8 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -436,5 +404,27 @@ description: Artifact commands assembly_mixed_units_cubes.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/assembly_mixed_units_cubes/ops.snap

@@ -2,7 +2,114 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed assembly_mixed_units_cubes.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/cube-inches.kcl": [
+    {
+      "type": "StdLibCall",
+      "name": "startSketchOn",
+      "unlabeledArg": {
+        "value": {
+          "type": "Plane",
+          "artifact_id": "[uuid]"
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {},
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "StdLibCall",
+      "name": "extrude",
+      "unlabeledArg": {
+        "value": {
+          "type": "Sketch",
+          "value": {
+            "artifactId": "[uuid]"
+          }
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {
+        "length": {
+          "value": {
+            "type": "Number",
+            "value": 5.0,
+            "ty": {
+              "type": "Default",
+              "len": {
+                "type": "Inches"
+              },
+              "angle": {
+                "type": "Degrees"
+              }
+            }
+          },
+          "sourceRange": []
+        }
+      },
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    }
+  ],
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/cube-mm.kcl": [
+    {
+      "type": "StdLibCall",
+      "name": "startSketchOn",
+      "unlabeledArg": {
+        "value": {
+          "type": "Plane",
+          "artifact_id": "[uuid]"
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {},
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    },
+    {
+      "type": "StdLibCall",
+      "name": "extrude",
+      "unlabeledArg": {
+        "value": {
+          "type": "Sketch",
+          "value": {
+            "artifactId": "[uuid]"
+          }
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {
+        "length": {
+          "value": {
+            "type": "Number",
+            "value": 5.0,
+            "ty": {
+              "type": "Default",
+              "len": {
+                "type": "Mm"
+              },
+              "angle": {
+                "type": "Degrees"
+              }
+            }
+          },
+          "sourceRange": []
+        }
+      },
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    }
+  ],
+  "rust/kcl-lib/tests/assembly_mixed_units_cubes/input.kcl": [
     {
       "type": "GroupBegin",
       "group": {
@@ -20,6 +127,9 @@ description: Operations executed assembly_mixed_units_cubes.kcl
       },
       "sourceRange": []
     },
+    {
+      "type": "GroupEnd"
+    },
     {
       "type": "GroupBegin",
       "group": {
@@ -37,10 +147,19 @@ description: Operations executed assembly_mixed_units_cubes.kcl
       },
       "sourceRange": []
     },
-  {
-    "type": "GroupEnd"
-  },
     {
       "type": "GroupEnd"
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/assembly_non_default_units/artifact_commands.snap

@@ -2,33 +2,10 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands assembly_non_default_units.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/assembly_non_default_units/globals.kcl": [],
+  "rust/kcl-lib/tests/assembly_non_default_units/input.kcl": [],
+  "rust/kcl-lib/tests/assembly_non_default_units/other1.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -54,14 +31,6 @@ description: Artifact commands assembly_non_default_units.kcl
         "hide": true
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "close_path",
-      "path_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -78,6 +47,33 @@ description: Artifact commands assembly_non_default_units.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "move_path_pen",
+        "path": "[uuid]",
+        "to": {
+          "x": 25.4,
+          "y": 0.0,
+          "z": 0.0
+        }
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -107,29 +103,12 @@ description: Artifact commands assembly_non_default_units.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "move_path_pen",
-      "path": "[uuid]",
-      "to": {
-        "x": 25.4,
-        "y": 0.0,
-        "z": 0.0
+        "type": "close_path",
+        "path_id": "[uuid]"
       }
     }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
+  ],
+  "rust/kcl-lib/tests/assembly_non_default_units/other2.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -155,14 +134,6 @@ description: Artifact commands assembly_non_default_units.kcl
         "hide": true
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "close_path",
-      "path_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -179,6 +150,33 @@ description: Artifact commands assembly_non_default_units.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "move_path_pen",
+        "path": "[uuid]",
+        "to": {
+          "x": 25.4,
+          "y": 50.8,
+          "z": 0.0
+        }
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -208,27 +206,20 @@ description: Artifact commands assembly_non_default_units.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "move_path_pen",
-      "path": "[uuid]",
-      "to": {
-        "x": 25.4,
-        "y": 50.8,
-        "z": 0.0
+        "type": "close_path",
+        "path_id": "[uuid]"
       }
     }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/assembly_non_default_units/ops.snap

@@ -2,24 +2,9 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed assembly_non_default_units.kcl
 ---
-[
-  {
-    "type": "GroupBegin",
-    "group": {
-      "type": "ModuleInstance",
-      "name": "other1.kcl",
-      "moduleId": 0
-    },
-    "nodePath": {
-      "steps": [
-        {
-          "type": "ProgramBodyItem",
-          "index": 0
-        }
-      ]
-    },
-    "sourceRange": []
-  },
+{
+  "rust/kcl-lib/tests/assembly_non_default_units/globals.kcl": [],
+  "rust/kcl-lib/tests/assembly_non_default_units/input.kcl": [
     {
       "type": "GroupBegin",
       "group": {
@@ -40,7 +25,72 @@ description: Operations executed assembly_non_default_units.kcl
     {
       "type": "GroupEnd"
     },
+    {
+      "type": "GroupBegin",
+      "group": {
+        "type": "ModuleInstance",
+        "name": "other1.kcl",
+        "moduleId": 0
+      },
+      "nodePath": {
+        "steps": [
+          {
+            "type": "ProgramBodyItem",
+            "index": 0
+          }
+        ]
+      },
+      "sourceRange": []
+    },
     {
       "type": "GroupEnd"
     }
-]
+  ],
+  "rust/kcl-lib/tests/assembly_non_default_units/other1.kcl": [
+    {
+      "type": "StdLibCall",
+      "name": "startSketchOn",
+      "unlabeledArg": {
+        "value": {
+          "type": "Plane",
+          "artifact_id": "[uuid]"
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {},
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    }
+  ],
+  "rust/kcl-lib/tests/assembly_non_default_units/other2.kcl": [
+    {
+      "type": "StdLibCall",
+      "name": "startSketchOn",
+      "unlabeledArg": {
+        "value": {
+          "type": "Plane",
+          "artifact_id": "[uuid]"
+        },
+        "sourceRange": []
+      },
+      "labeledArgs": {},
+      "nodePath": {
+        "steps": []
+      },
+      "sourceRange": []
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/bad_units_in_annotation/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands bad_units_in_annotation.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/bad_units_in_annotation/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/bad_units_in_annotation/ops.snap

@@ -2,4 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed bad_units_in_annotation.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/bad_units_in_annotation/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_close_opposite/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_fillet_cube_close_opposite.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_close_opposite/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,7 +177,9 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
+        "type": "solid3d_get_extrusion_face_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
     },
     {
@@ -211,9 +195,10 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_opposite_edge",
         "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "edge_id": "[uuid]",
+        "face_id": "[uuid]"
       }
     },
     {
@@ -235,15 +220,17 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
           "[uuid]"
         ]
       }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_opposite_edge",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]",
-      "face_id": "[uuid]"
     }
-  }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_close_opposite/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_fillet_cube_close_opposite.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_close_opposite/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -151,4 +152,16 @@ description: Operations executed basic_fillet_cube_close_opposite.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_end/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_fillet_cube_end.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_end/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands basic_fillet_cube_end.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands basic_fillet_cube_end.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands basic_fillet_cube_end.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,7 +177,9 @@ description: Artifact commands basic_fillet_cube_end.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
+        "type": "solid3d_get_extrusion_face_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
     },
     {
@@ -211,9 +195,10 @@ description: Artifact commands basic_fillet_cube_end.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_opposite_edge",
         "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "edge_id": "[uuid]",
+        "face_id": "[uuid]"
       }
     },
     {
@@ -235,15 +220,17 @@ description: Artifact commands basic_fillet_cube_end.kcl
           "[uuid]"
         ]
       }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_opposite_edge",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]",
-      "face_id": "[uuid]"
     }
-  }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_end/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_fillet_cube_end.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_end/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -151,4 +152,16 @@ description: Operations executed basic_fillet_cube_end.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_next_adjacent/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_fillet_cube_next_adjacent.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_next_adjacent/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,7 +177,9 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
+        "type": "solid3d_get_extrusion_face_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
     },
     {
@@ -211,9 +195,10 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_next_adjacent_edge",
         "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "edge_id": "[uuid]",
+        "face_id": "[uuid]"
       }
     },
     {
@@ -232,15 +217,17 @@ description: Artifact commands basic_fillet_cube_next_adjacent.kcl
         "strategy": "automatic",
         "extra_face_ids": []
       }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_next_adjacent_edge",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]",
-      "face_id": "[uuid]"
     }
-  }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_next_adjacent/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_fillet_cube_next_adjacent.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_next_adjacent/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -146,4 +147,16 @@ description: Operations executed basic_fillet_cube_next_adjacent.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_previous_adjacent/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_previous_adjacent/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,7 +177,9 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
+        "type": "solid3d_get_extrusion_face_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
     },
     {
@@ -211,9 +195,10 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_prev_adjacent_edge",
         "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "edge_id": "[uuid]",
+        "face_id": "[uuid]"
       }
     },
     {
@@ -232,15 +217,17 @@ description: Artifact commands basic_fillet_cube_previous_adjacent.kcl
         "strategy": "automatic",
         "extra_face_ids": []
       }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_prev_adjacent_edge",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]",
-      "face_id": "[uuid]"
     }
-  }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_previous_adjacent/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_fillet_cube_previous_adjacent.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_previous_adjacent/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -146,4 +147,16 @@ description: Operations executed basic_fillet_cube_previous_adjacent.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_start/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_fillet_cube_start.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_start/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -70,6 +45,13 @@ description: Artifact commands basic_fillet_cube_start.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -90,13 +72,6 @@ description: Artifact commands basic_fillet_cube_start.kcl
         "type": "sketch_mode_disable"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -183,6 +158,13 @@ description: Artifact commands basic_fillet_cube_start.kcl
         "opposite": "None"
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -195,14 +177,7 @@ description: Artifact commands basic_fillet_cube_start.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_get_adjacency_info",
+        "type": "solid3d_get_extrusion_face_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -211,7 +186,7 @@ description: Artifact commands basic_fillet_cube_start.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_extrusion_face_info",
+        "type": "solid3d_get_adjacency_info",
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
@@ -236,4 +211,16 @@ description: Artifact commands basic_fillet_cube_start.kcl
         ]
       }
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_fillet_cube_start/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_fillet_cube_start.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_fillet_cube_start/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -152,4 +153,16 @@ description: Operations executed basic_fillet_cube_start.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_revolve_circle/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands basic_revolve_circle.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/basic_revolve_circle/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -54,14 +29,6 @@ description: Artifact commands basic_revolve_circle.kcl
         "hide": true
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "close_path",
-      "path_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -78,6 +45,33 @@ description: Artifact commands basic_revolve_circle.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "move_path_pen",
+        "path": "[uuid]",
+        "to": {
+          "x": 20.0,
+          "y": 0.0,
+          "z": 0.0
+        }
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -107,35 +101,8 @@ description: Artifact commands basic_revolve_circle.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "move_path_pen",
-      "path": "[uuid]",
-      "to": {
-        "x": 20.0,
-        "y": 0.0,
-        "z": 0.0
-      }
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
+        "type": "close_path",
+        "path_id": "[uuid]"
       }
     },
     {
@@ -167,9 +134,8 @@ description: Artifact commands basic_revolve_circle.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -180,5 +146,26 @@ description: Artifact commands basic_revolve_circle.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/basic_revolve_circle/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed basic_revolve_circle.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/basic_revolve_circle/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -154,4 +155,16 @@ description: Operations executed basic_revolve_circle.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_and/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands boolean_logical_and.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/boolean_logical_and/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_and/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed boolean_logical_and.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/boolean_logical_and/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_multiple/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands boolean_logical_multiple.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/boolean_logical_multiple/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_multiple/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed boolean_logical_multiple.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/boolean_logical_multiple/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_or/artifact_commands.snap

@@ -2,31 +2,17 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands boolean_logical_or.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  }
-]
+{
+  "rust/kcl-lib/tests/boolean_logical_or/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/boolean_logical_or/ops.snap

@@ -1,5 +1,18 @@
 ---
-source: kcl/src/simulation_tests.rs
+source: kcl-lib/src/simulation_tests.rs
 description: Operations executed boolean_logical_or.kcl
 ---
-[]
+{
+  "rust/kcl-lib/tests/boolean_logical_or/input.kcl": [],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/circle_three_point/artifact_commands.snap

@@ -2,33 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Artifact commands circle_three_point.kcl
 ---
-[
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "edge_lines_visible",
-      "hidden": false
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_visible",
-      "object_id": "[uuid]",
-      "hidden": true
-    }
-  },
+{
+  "rust/kcl-lib/tests/circle_three_point/input.kcl": [
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -54,14 +29,6 @@ description: Artifact commands circle_three_point.kcl
         "hide": true
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "close_path",
-      "path_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -78,6 +45,33 @@ description: Artifact commands circle_three_point.kcl
         }
       }
     },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "start_path"
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "move_path_pen",
+        "path": "[uuid]",
+        "to": {
+          "x": 30.006,
+          "y": 19.75,
+          "z": 0.0
+        }
+      }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "sketch_mode_disable"
+      }
+    },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -107,27 +101,8 @@ description: Artifact commands circle_three_point.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "move_path_pen",
-      "path": "[uuid]",
-      "to": {
-        "x": 30.006,
-        "y": 19.75,
-        "z": 0.0
-      }
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "sketch_mode_disable"
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "start_path"
+        "type": "close_path",
+        "path_id": "[uuid]"
       }
     },
     {
@@ -157,14 +132,6 @@ description: Artifact commands circle_three_point.kcl
         "opposite": "None"
       }
     },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "object_bring_to_front",
-      "object_id": "[uuid]"
-    }
-  },
     {
       "cmdId": "[uuid]",
       "range": [],
@@ -176,9 +143,8 @@ description: Artifact commands circle_three_point.kcl
       "cmdId": "[uuid]",
       "range": [],
       "command": {
-      "type": "solid3d_get_adjacency_info",
-      "object_id": "[uuid]",
-      "edge_id": "[uuid]"
+        "type": "object_bring_to_front",
+        "object_id": "[uuid]"
       }
     },
     {
@@ -189,5 +155,26 @@ description: Artifact commands circle_three_point.kcl
         "object_id": "[uuid]",
         "edge_id": "[uuid]"
       }
+    },
+    {
+      "cmdId": "[uuid]",
+      "range": [],
+      "command": {
+        "type": "solid3d_get_adjacency_info",
+        "object_id": "[uuid]",
+        "edge_id": "[uuid]"
       }
-]
+    }
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}

rust/kcl-lib/tests/circle_three_point/ops.snap

@@ -2,7 +2,8 @@
 source: kcl-lib/src/simulation_tests.rs
 description: Operations executed circle_three_point.kcl
 ---
-[
+{
+  "rust/kcl-lib/tests/circle_three_point/input.kcl": [
     {
       "type": "StdLibCall",
       "name": "startSketchOn",
@@ -84,4 +85,16 @@ description: Operations executed circle_three_point.kcl
       },
       "sourceRange": []
     }
-]
+  ],
+  "std::appearance": [],
+  "std::array": [],
+  "std::math": [],
+  "std::prelude": [],
+  "std::sketch": [],
+  "std::solid": [],
+  "std::sweep": [],
+  "std::transform": [],
+  "std::turns": [],
+  "std::types": [],
+  "std::units": []
+}