zoo-kcl 0.3.99__tar.gz → 0.3.101__tar.gz

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/Cargo.lock

@@ -2524,7 +2524,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-api"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
  "indexmap 2.11.4",
  "kcl-error",
@@ -2535,7 +2535,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "anyhow",
  "clap",
@@ -2546,7 +2546,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2555,7 +2555,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -2565,7 +2565,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-error"
-version = "0.1.6"
+version = "0.1.8"
 dependencies = [
  "miette",
  "serde",
@@ -2588,7 +2588,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.99"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "clap",
@@ -2609,7 +2609,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "anyhow",
  "clap",
@@ -2629,7 +2629,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.99"
+version = "0.2.101"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -2709,7 +2709,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.99"
+version = "0.3.101"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -2725,7 +2725,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -2738,7 +2738,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2752,7 +2752,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.99"
+version = "0.1.101"
 dependencies = [
  "anyhow",
  "bson",
@@ -2820,9 +2820,9 @@ dependencies = [
 
 [[package]]
 name = "kittycad-modeling-cmds"
-version = "0.2.143"
+version = "0.2.144"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "503df8ed39129217980214fb623cf13b5511df34d8da4db977980cac6a511ee5"
+checksum = "58c575ffec0c363c3cfcffcfcce8891dc365f9cbe7fe79404ed2087e7664f10c"
 dependencies = [
  "anyhow",
  "chrono",
@@ -5277,9 +5277,9 @@ checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "tempfile"
-version = "3.21.0"
+version = "3.23.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15b61f8f20e3a6f7e0649d825294eaf317edce30f82cf6026e7e4cb9222a7d1e"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
 dependencies = [
  "fastrand",
  "getrandom 0.3.1",
@@ -5501,9 +5501,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.27.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "489a59b6730eda1b0171fcfda8b121f4bee2b35cba8645ca35c5f7ba3eb736c1"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
 dependencies = [
  "futures-util",
  "log",
@@ -5824,9 +5824,9 @@ dependencies = [
 
 [[package]]
 name = "tungstenite"
-version = "0.27.0"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadc29d668c91fcc564941132e17b28a7ceb2f3ebf0b9dae3e03fd7a6748eb0d"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
  "bytes",
  "data-encoding",

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/Cargo.toml

@@ -15,7 +15,7 @@ kittycad = { version = "0.4.2", default-features = false, features = [
   "js",
   "requests",
 ] }
-kittycad-modeling-cmds = { version = "0.2.143", features = [
+kittycad-modeling-cmds = { version = "0.2.144", features = [
   "ts-rs",
   "websocket",
 ] }

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoo-kcl
-Version: 0.3.99
+Version: 0.3.101
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-api/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-api"
-version = "0.1.6"
+version = "0.1.8"
 edition = "2024"
 description = "KCL interpreter API"
 license = "MIT"

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-derive-docs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-derive-docs"
 description = "A tool for generating documentation from Rust derive macros"
-version = "0.1.99"
+version = "0.1.101"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-derive-docs/src/example_tests.rs

@@ -67,6 +67,10 @@ pub const TEST_NAMES: &[&str] = &[
     "std-clone-7",
     "std-clone-8",
     "std-clone-9",
+    "std-gdt-datum-0",
+    "std-gdt-flatness-0",
+    "std-gdt-flatness-1",
+    "std-gdt-flatness-2",
     "std-helix-0",
     "std-helix-1",
     "std-helix-2",

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-directory-test-macro/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-directory-test-macro"
 description = "A tool for generating tests from a directory of kcl files"
-version = "0.1.99"
+version = "0.1.101"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-error"
-version = "0.1.6"
+version = "0.1.8"
 edition = "2024"
 description = "KCL error definitions"
 license = "MIT"

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.99"
+version = "0.2.101"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
@@ -98,7 +98,7 @@ serde = { workspace = true }
 serde_json = { workspace = true }
 sha2 = "0.10.9"
 tabled = { version = "0.20.0", optional = true }
-tempfile = "3.21"
+tempfile = "3.23"
 thiserror = "2.0.16"
 toml = "0.9.6"
 ts-rs = { version = "11.0.1", features = [
@@ -120,7 +120,7 @@ zip = { workspace = true }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 tokio = { workspace = true, features = ["full"] }
-tokio-tungstenite = { version = "0.27.0", features = [
+tokio-tungstenite = { version = "0.28.0", features = [
   "rustls-tls-native-roots",
 ] }
 tower-lsp = { workspace = true, features = ["proposed", "default"] }

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/execution/exec_ast.rs

@@ -712,7 +712,7 @@ impl ExecutorContext {
     }
 
     #[async_recursion]
-    pub(super) async fn execute_expr<'a: 'async_recursion>(
+    pub(crate) async fn execute_expr<'a: 'async_recursion>(
         &self,
         init: &Expr,
         exec_state: &mut ExecState,

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/execution/mod.rs

@@ -60,7 +60,7 @@ mod state;
 pub mod typed_path;
 pub(crate) mod types;
 
-enum StatementKind<'a> {
+pub(crate) enum StatementKind<'a> {
     Declaration { name: &'a str },
     Expression,
 }

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/modules.rs

@@ -60,6 +60,7 @@ impl ModuleLoader {
 pub(crate) fn read_std(mod_name: &str) -> Option<&'static str> {
     match mod_name {
         "prelude" => Some(include_str!("../std/prelude.kcl")),
+        "gdt" => Some(include_str!("../std/gdt.kcl")),
         "math" => Some(include_str!("../std/math.kcl")),
         "sketch" => Some(include_str!("../std/sketch.kcl")),
         "sketch2" => Some(include_str!("../std/sketch2.kcl")),

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/simulation_tests.rs

@@ -3941,3 +3941,24 @@ mod union_self {
         super::execute(TEST_NAME, true).await
     }
 }
+mod plane_of_chamfer {
+    const TEST_NAME: &str = "plane_of_chamfer";
+
+    /// Test parsing KCL.
+    #[test]
+    fn parse() {
+        super::parse(TEST_NAME)
+    }
+
+    /// Test that parsing and unparsing KCL produces the original KCL input.
+    #[tokio::test(flavor = "multi_thread")]
+    async fn unparse() {
+        super::unparse(TEST_NAME).await
+    }
+
+    /// Test that KCL is executed correctly.
+    #[tokio::test(flavor = "multi_thread")]
+    async fn kcl_test_execute() {
+        super::execute(TEST_NAME, true).await
+    }
+}

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/std/args.rs

@@ -471,17 +471,13 @@ impl<'a> FromKclValue<'a> for TagIdentifier {
 
 impl<'a> FromKclValue<'a> for Vec<TagIdentifier> {
     fn from_kcl_val(arg: &'a KclValue) -> Option<Self> {
-        match arg {
-            KclValue::HomArray { value, .. } => {
-                let tags = value.iter().map(|v| v.get_tag_identifier().unwrap()).collect();
-                Some(tags)
-            }
-            KclValue::Tuple { value, .. } => {
-                let tags = value.iter().map(|v| v.get_tag_identifier().unwrap()).collect();
-                Some(tags)
-            }
-            _ => None,
-        }
+        let tags = arg
+            .clone()
+            .into_array()
+            .iter()
+            .map(|v| v.get_tag_identifier().unwrap())
+            .collect();
+        Some(tags)
     }
 }
 

zoo_kcl-0.3.101/kcl-lib/src/std/gdt.rs

@@ -0,0 +1,288 @@
+use kcl_error::SourceRange;
+use kcmc::{ModelingCmd, each_cmd as mcmd};
+use kittycad_modeling_cmds::{
+    self as kcmc,
+    shared::{
+        AnnotationFeatureControl, AnnotationLineEnd, AnnotationMbdControlFrame, AnnotationOptions, AnnotationType,
+        MbdSymbol, Point2d as KPoint2d,
+    },
+};
+
+use crate::{
+    ExecState, KclError,
+    errors::KclErrorDetails,
+    exec::KclValue,
+    execution::{
+        Metadata, Plane, StatementKind, TagIdentifier,
+        types::{ArrayLen, RuntimeType},
+    },
+    parsing::ast::types as ast,
+    std::{Args, args::TyF64, sketch::make_sketch_plane_from_orientation},
+};
+
+/// Bundle of common GD&T annotation style arguments.
+#[derive(Debug, Clone)]
+pub(crate) struct AnnotationStyle {
+    pub font_point_size: Option<TyF64>,
+    pub font_scale: Option<TyF64>,
+}
+
+pub async fn datum(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+    let face: TagIdentifier = args.get_kw_arg("face", &RuntimeType::tagged_face(), exec_state)?;
+    let name: String = args.get_kw_arg("name", &RuntimeType::string(), exec_state)?;
+    let frame_position: Option<[TyF64; 2]> =
+        args.get_kw_arg_opt("framePosition", &RuntimeType::point2d(), exec_state)?;
+    let frame_plane: Option<Plane> = args.get_kw_arg_opt("framePlane", &RuntimeType::plane(), exec_state)?;
+    let font_point_size: Option<TyF64> = args.get_kw_arg_opt("fontPointSize", &RuntimeType::count(), exec_state)?;
+    let font_scale: Option<TyF64> = args.get_kw_arg_opt("fontScale", &RuntimeType::count(), exec_state)?;
+
+    inner_datum(
+        face,
+        name,
+        frame_position,
+        frame_plane,
+        AnnotationStyle {
+            font_point_size,
+            font_scale,
+        },
+        exec_state,
+        &args,
+    )
+    .await?;
+    Ok(KclValue::none())
+}
+
+async fn inner_datum(
+    face: TagIdentifier,
+    name: String,
+    frame_position: Option<[TyF64; 2]>,
+    frame_plane: Option<Plane>,
+    style: AnnotationStyle,
+    exec_state: &mut ExecState,
+    args: &Args,
+) -> Result<(), KclError> {
+    const DATUM_LENGTH_ERROR: &str = "Datum name must be a single character.";
+    if name.len() > 1 {
+        return Err(KclError::new_semantic(KclErrorDetails::new(
+            DATUM_LENGTH_ERROR.to_owned(),
+            vec![args.source_range],
+        )));
+    }
+    let name_char = name.chars().next().ok_or_else(|| {
+        KclError::new_semantic(KclErrorDetails::new(
+            DATUM_LENGTH_ERROR.to_owned(),
+            vec![args.source_range],
+        ))
+    })?;
+    let frame_plane = if let Some(plane) = frame_plane {
+        plane
+    } else {
+        // No plane given. Use one of the standard planes.
+        xy_plane(exec_state, args).await?
+    };
+    let frame_plane_id = if frame_plane.value == crate::exec::PlaneType::Uninit {
+        // Create it in the engine.
+        let engine_plane =
+            make_sketch_plane_from_orientation(frame_plane.info.into_plane_data(), exec_state, args).await?;
+        engine_plane.id
+    } else {
+        frame_plane.id
+    };
+    let face_id = args.get_adjacent_face_to_tag(exec_state, &face, false).await?;
+    exec_state
+        .batch_modeling_cmd(
+            args.into(),
+            ModelingCmd::from(mcmd::NewAnnotation {
+                options: AnnotationOptions {
+                    text: None,
+                    line_ends: None,
+                    line_width: None,
+                    color: None,
+                    position: None,
+                    dimension: None,
+                    feature_control: Some(AnnotationFeatureControl {
+                        entity_id: face_id,
+                        // Point to the center of the face.
+                        entity_pos: KPoint2d { x: 0.5, y: 0.5 },
+                        leader_type: AnnotationLineEnd::Dot,
+                        dimension: None,
+                        control_frame: None,
+                        defined_datum: Some(name_char),
+                        prefix: None,
+                        suffix: None,
+                        plane_id: frame_plane_id,
+                        offset: if let Some(offset) = &frame_position {
+                            KPoint2d {
+                                x: offset[0].to_mm(),
+                                y: offset[1].to_mm(),
+                            }
+                        } else {
+                            KPoint2d { x: 100.0, y: 100.0 }
+                        },
+                        precision: 0,
+                        font_scale: style.font_scale.as_ref().map(|n| n.n as f32).unwrap_or(1.0),
+                        font_point_size: style.font_point_size.as_ref().map(|n| n.n.round() as u32).unwrap_or(36),
+                    }),
+                    feature_tag: None,
+                },
+                clobber: false,
+                annotation_type: AnnotationType::T3D,
+            }),
+        )
+        .await?;
+    Ok(())
+}
+
+pub async fn flatness(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+    let faces: Vec<TagIdentifier> = args.get_kw_arg(
+        "faces",
+        &RuntimeType::Array(Box::new(RuntimeType::tagged_face()), ArrayLen::Minimum(1)),
+        exec_state,
+    )?;
+    let tolerance = args.get_kw_arg("tolerance", &RuntimeType::length(), exec_state)?;
+    let precision = args.get_kw_arg_opt("precision", &RuntimeType::count(), exec_state)?;
+    let frame_position: Option<[TyF64; 2]> =
+        args.get_kw_arg_opt("framePosition", &RuntimeType::point2d(), exec_state)?;
+    let frame_plane: Option<Plane> = args.get_kw_arg_opt("framePlane", &RuntimeType::plane(), exec_state)?;
+    let font_point_size: Option<TyF64> = args.get_kw_arg_opt("fontPointSize", &RuntimeType::count(), exec_state)?;
+    let font_scale: Option<TyF64> = args.get_kw_arg_opt("fontScale", &RuntimeType::count(), exec_state)?;
+
+    inner_flatness(
+        faces,
+        tolerance,
+        precision,
+        frame_position,
+        frame_plane,
+        AnnotationStyle {
+            font_point_size,
+            font_scale,
+        },
+        exec_state,
+        &args,
+    )
+    .await?;
+    Ok(KclValue::none())
+}
+
+#[allow(clippy::too_many_arguments)]
+async fn inner_flatness(
+    faces: Vec<TagIdentifier>,
+    tolerance: TyF64,
+    precision: Option<TyF64>,
+    frame_position: Option<[TyF64; 2]>,
+    frame_plane: Option<Plane>,
+    style: AnnotationStyle,
+    exec_state: &mut ExecState,
+    args: &Args,
+) -> Result<(), KclError> {
+    let frame_plane = if let Some(plane) = frame_plane {
+        plane
+    } else {
+        // No plane given. Use one of the standard planes.
+        xy_plane(exec_state, args).await?
+    };
+    let frame_plane_id = if frame_plane.value == crate::exec::PlaneType::Uninit {
+        // Create it in the engine.
+        let engine_plane =
+            make_sketch_plane_from_orientation(frame_plane.info.into_plane_data(), exec_state, args).await?;
+        engine_plane.id
+    } else {
+        frame_plane.id
+    };
+    for face in &faces {
+        let face_id = args.get_adjacent_face_to_tag(exec_state, face, false).await?;
+        exec_state
+            .batch_modeling_cmd(
+                args.into(),
+                ModelingCmd::from(mcmd::NewAnnotation {
+                    options: AnnotationOptions {
+                        text: None,
+                        line_ends: None,
+                        line_width: None,
+                        color: None,
+                        position: None,
+                        dimension: None,
+                        feature_control: Some(AnnotationFeatureControl {
+                            entity_id: face_id,
+                            // Point to the center of the face.
+                            entity_pos: KPoint2d { x: 0.5, y: 0.5 },
+                            leader_type: AnnotationLineEnd::Dot,
+                            dimension: None,
+                            control_frame: Some(AnnotationMbdControlFrame {
+                                symbol: MbdSymbol::Flatness,
+                                diameter_symbol: None,
+                                tolerance: tolerance.to_mm(),
+                                modifier: None,
+                                primary_datum: None,
+                                secondary_datum: None,
+                                tertiary_datum: None,
+                            }),
+                            defined_datum: None,
+                            prefix: None,
+                            suffix: None,
+                            plane_id: frame_plane_id,
+                            offset: if let Some(offset) = &frame_position {
+                                KPoint2d {
+                                    x: offset[0].to_mm(),
+                                    y: offset[1].to_mm(),
+                                }
+                            } else {
+                                KPoint2d { x: 100.0, y: 100.0 }
+                            },
+                            precision: precision.as_ref().map(|n| n.n.round() as u32).unwrap_or(3),
+                            font_scale: style.font_scale.as_ref().map(|n| n.n as f32).unwrap_or(1.0),
+                            font_point_size: style.font_point_size.as_ref().map(|n| n.n.round() as u32).unwrap_or(36),
+                        }),
+                        feature_tag: None,
+                    },
+                    clobber: false,
+                    annotation_type: AnnotationType::T3D,
+                }),
+            )
+            .await?;
+    }
+    Ok(())
+}
+
+/// Get the XY plane by evaluating the `XY` expression so that it's the same as
+/// if the user specified `XY`.
+async fn xy_plane(exec_state: &mut ExecState, args: &Args) -> Result<Plane, KclError> {
+    let plane_ast = plane_ast("XY", args.source_range);
+    let metadata = Metadata::from(args.source_range);
+    let plane_value = args
+        .ctx
+        .execute_expr(&plane_ast, exec_state, &metadata, &[], StatementKind::Expression)
+        .await?
+        .clone();
+    Ok(plane_value
+        .as_plane()
+        .ok_or_else(|| {
+            KclError::new_internal(KclErrorDetails::new(
+                "Expected XY plane to be defined".to_owned(),
+                vec![args.source_range],
+            ))
+        })?
+        .clone())
+}
+
+/// An AST node for a plane with the given name.
+fn plane_ast(plane_name: &str, range: SourceRange) -> ast::Node<ast::Expr> {
+    ast::Node::new(
+        ast::Expr::Name(Box::new(ast::Node::new(
+            ast::Name {
+                name: ast::Identifier::new(plane_name),
+                path: Vec::new(),
+                // TODO: We may want to set this to true once we implement it to
+                // prevent it breaking if users redefine the identifier.
+                abs_path: false,
+                digest: None,
+            },
+            range.start(),
+            range.end(),
+            range.module_id(),
+        ))),
+        range.start(),
+        range.end(),
+        range.module_id(),
+    )
+}

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/std/mod.rs

@@ -12,6 +12,7 @@ pub mod csg;
 pub mod edge;
 pub mod extrude;
 pub mod fillet;
+pub mod gdt;
 pub mod helix;
 pub mod loft;
 pub mod math;
@@ -62,6 +63,14 @@ impl StdFnProps {
 
 pub(crate) fn std_fn(path: &str, fn_name: &str) -> (crate::std::StdFn, StdFnProps) {
     match (path, fn_name) {
+        ("gdt", "datum") => (
+            |e, a| Box::pin(crate::std::gdt::datum(e, a)),
+            StdFnProps::default("std::gdt::datum").include_in_feature_tree(),
+        ),
+        ("gdt", "flatness") => (
+            |e, a| Box::pin(crate::std::gdt::flatness(e, a)),
+            StdFnProps::default("std::gdt::flatness").include_in_feature_tree(),
+        ),
         ("math", "cos") => (
             |e, a| Box::pin(crate::std::math::cos(e, a)),
             StdFnProps::default("std::math::cos"),

{zoo_kcl-0.3.99 → zoo_kcl-0.3.101}/kcl-lib/src/std/planes.rs

@@ -60,6 +60,11 @@ pub(crate) async fn inner_plane_of(
         });
     }
 
+    // Flush the batch for our fillets/chamfers if there are any.
+    exec_state
+        .flush_batch_for_solids(args.into(), std::slice::from_ref(&solid))
+        .await?;
+
     // Query the engine to learn what plane, if any, this face is on.
     let face_id = face.get_face_id(&solid, exec_state, args, true).await?;
     let plane_id = exec_state.id_generator().next_uuid();