Sketch 2.0 WIP, unknown branch, PR'd for commets

.gitignore

@@ -78,3 +78,4 @@ venv
 .vscode-test
 .biome/
 .million
+.cursor

rust/kcl-api/src/lib.rs

@@ -2,7 +2,7 @@
 
 #![allow(async_fn_in_trait)]
 
-use kcl_error::SourceRange;
+use kcl_error::{CompilationError, SourceRange};
 use serde::{Deserialize, Serialize};
 
 pub mod sketch;
@@ -105,6 +105,7 @@ pub struct Object {
 #[allow(clippy::large_enum_variant)]
 #[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
 pub enum ObjectKind {
+    Plane(Plane),
     Sketch(crate::sketch::Sketch),
     Segment(crate::sketch::Segment),
     Constraint(crate::sketch::Constraint),
@@ -116,7 +117,40 @@ pub enum ObjectKind {
 #[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
 pub enum Plane {
     Object(ObjectId),
-    Default,
+    Default(StandardPlane),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Deserialize, Serialize, ts_rs::TS)]
+pub enum StandardPlane {
+    #[serde(rename = "XY")]
+    XY,
+    #[serde(rename = "YZ")]
+    YZ,
+    #[serde(rename = "XZ")]
+    XZ,
+}
+
+impl std::fmt::Display for StandardPlane {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StandardPlane::XY => write!(f, "XY"),
+            StandardPlane::YZ => write!(f, "YZ"),
+            StandardPlane::XZ => write!(f, "XZ"),
+        }
+    }
+}
+
+impl std::str::FromStr for StandardPlane {
+    type Err = CompilationError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        match s {
+            "XY" => Ok(StandardPlane::XY),
+            "YZ" => Ok(StandardPlane::YZ),
+            "XZ" => Ok(StandardPlane::XZ),
+            _ => Err(CompilationError::err(SourceRange::default(), "invalid standard plane")),
+        }
+    }
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
@@ -125,14 +159,20 @@ pub enum SourceRef {
     BackTrace(Vec<SourceRange>),
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+impl From<SourceRange> for SourceRef {
+    fn from(value: SourceRange) -> Self {
+        Self::Simple(value)
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct Number {
-    value: f64,
-    units: NumericSuffix,
+    pub value: f64,
+    pub units: NumericSuffix,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub enum Expr {
     Number(Number),

rust/kcl-api/src/sketch.rs

@@ -84,7 +84,7 @@ pub struct SketchArgs {
     pub on: Plane,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiPoint")]
 pub struct Point {
     pub position: Point2d<Number>,
@@ -94,15 +94,15 @@ pub struct Point {
     pub constraints: Vec<ObjectId>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub enum Freedom {
     Free,
     Partial,
     Fixed,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiSegment")]
 pub enum Segment {
     Point(Point),
@@ -111,7 +111,7 @@ pub enum Segment {
     Circle(Circle),
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub enum SegmentCtor {
     Point(Point2d<Expr>),
@@ -124,14 +124,14 @@ pub enum SegmentCtor {
     ThreePointCircle(ThreePointCircleCtor),
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiPoint2d")]
 pub struct Point2d<U: std::fmt::Debug + Clone + ts_rs::TS> {
     pub x: U,
     pub y: U,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiLine")]
 pub struct Line {
     pub start: ObjectId,
@@ -146,28 +146,28 @@ pub struct Line {
     pub ctor_applicable: bool,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct LineCtor {
     pub start: Point2d<Expr>,
     pub end: Point2d<Expr>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct MidPointLineCtor {
     pub midpoint: Point2d<Expr>,
     pub start_or_end: StartOrEnd<Point2d<Expr>>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiStartOrEnd")]
 pub enum StartOrEnd<T> {
     Start(T),
     End(T),
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiArc")]
 pub struct Arc {
     pub start: ObjectId,
@@ -178,31 +178,31 @@ pub struct Arc {
     pub ctor_applicable: bool,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct ArcCtor {
     pub start: Point2d<Expr>,
     pub end: Point2d<Expr>,
     pub center: Point2d<Expr>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct ThreePointArcCtor {
     pub start: Point2d<Expr>,
     pub end: Point2d<Expr>,
     pub interior: Point2d<Expr>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct TangentArcCtor {
     pub start: Point2d<Expr>,
     pub end: Point2d<Expr>,
     pub tangent: StartOrEnd<ObjectId>,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export, rename = "ApiCircle")]
 pub struct Circle {
     pub start: ObjectId,
@@ -212,14 +212,14 @@ pub struct Circle {
     pub ctor_applicable: bool,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct CircleCtor {
     pub center: Point2d<Expr>,
     pub radius: Expr,
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, ts_rs::TS)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, ts_rs::TS)]
 #[ts(export)]
 pub struct ThreePointCircleCtor {
     pub p1: Point2d<Expr>,

rust/kcl-lib/Cargo.toml

@@ -64,7 +64,6 @@ http = { workspace = true }
 image = { version = "0.25.8", default-features = false, features = ["png"] }
 indexmap = { workspace = true, features = ["serde", "rayon"] }
 itertools = "0.14.0"
-kcl-api = { version = "0.1", path = "../kcl-api" }
 kcl-derive-docs = { version = "0.1", path = "../kcl-derive-docs" }
 kcl-error = { version = "0.1", path = "../kcl-error" }
 kcl-ezpz = { workspace = true }

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

@@ -35,9 +35,17 @@ pub(crate) const IMPL: &str = "impl";
 pub(crate) const IMPL_RUST: &str = "std_rust";
 pub(crate) const IMPL_CONSTRAINT: &str = "std_rust_constraint";
 pub(crate) const IMPL_CONSTRAINABLE: &str = "std_constrainable";
+pub(crate) const IMPL_RUST_CONSTRAINABLE: &str = "std_rust_constrainable";
 pub(crate) const IMPL_KCL: &str = "kcl";
 pub(crate) const IMPL_PRIMITIVE: &str = "primitive";
-pub(super) const IMPL_VALUES: [&str; 5] = [IMPL_RUST, IMPL_KCL, IMPL_PRIMITIVE, IMPL_CONSTRAINT, IMPL_CONSTRAINABLE];
+pub(super) const IMPL_VALUES: [&str; 6] = [
+    IMPL_RUST,
+    IMPL_KCL,
+    IMPL_PRIMITIVE,
+    IMPL_CONSTRAINT,
+    IMPL_CONSTRAINABLE,
+    IMPL_RUST_CONSTRAINABLE,
+];
 
 pub(crate) const WARNINGS: &str = "warnings";
 pub(crate) const WARN_ALLOW: &str = "allow";
@@ -110,6 +118,7 @@ pub enum Impl {
     Kcl,
     KclConstrainable,
     Rust,
+    RustConstrainable,
     RustConstraint,
     Primitive,
 }
@@ -122,6 +131,7 @@ impl FromStr for Impl {
             IMPL_RUST => Ok(Self::Rust),
             IMPL_CONSTRAINT => Ok(Self::RustConstraint),
             IMPL_CONSTRAINABLE => Ok(Self::KclConstrainable),
+            IMPL_RUST_CONSTRAINABLE => Ok(Self::RustConstrainable),
             IMPL_KCL => Ok(Self::Kcl),
             IMPL_PRIMITIVE => Ok(Self::Primitive),
             _ => Err(()),

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

@@ -111,6 +111,12 @@ impl GlobalState {
             operations: self.exec_state.root_module_artifacts.operations,
             #[cfg(feature = "artifact-graph")]
             artifact_graph: self.exec_state.artifacts.graph,
+            #[cfg(feature = "artifact-graph")]
+            scene_objects: self.exec_state.root_module_artifacts.scene_objects,
+            #[cfg(feature = "artifact-graph")]
+            source_range_to_object: self.exec_state.root_module_artifacts.source_range_to_object,
+            #[cfg(feature = "artifact-graph")]
+            var_solutions: self.exec_state.root_module_artifacts.var_solutions,
             errors: self.exec_state.errors,
             default_planes: ctx.engine.get_default_planes().read().await.clone(),
         }

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

@@ -186,6 +186,9 @@ pub enum OpKclValue {
     Face {
         artifact_id: ArtifactId,
     },
+    Segment {
+        artifact_id: ArtifactId,
+    },
     Sketch {
         value: Box<OpSketch>,
     },
@@ -238,6 +241,10 @@ impl From<&KclValue> for OpKclValue {
                 value: value.initial_value,
                 ty: value.ty,
             },
+            KclValue::SketchConstraint { .. } => {
+                debug_assert!(false, "Sketch constraint cannot be represented in operations");
+                Self::KclNone {}
+            }
             KclValue::Tuple { value, .. } | KclValue::HomArray { value, .. } => {
                 let value = value.iter().map(Self::from).collect();
                 Self::Array { value }
@@ -262,6 +269,22 @@ impl From<&KclValue> for OpKclValue {
             KclValue::Face { value } => Self::Face {
                 artifact_id: value.artifact_id,
             },
+            KclValue::Segment { value } => match &value.repr {
+                crate::execution::geometry::SegmentRepr::Unsolved { .. } => {
+                    // Arguments to constraint functions will be unsolved.
+                    Self::KclNone {}
+                }
+                crate::execution::geometry::SegmentRepr::Solved { .. } => {
+                    debug_assert!(
+                        false,
+                        "Solved segment not sent to the engine cannot be represented in operations"
+                    );
+                    Self::KclNone {}
+                }
+                crate::execution::geometry::SegmentRepr::InEngine { id, .. } => Self::Segment {
+                    artifact_id: ArtifactId::new(*id),
+                },
+            },
             KclValue::Sketch { value } => Self::Sketch {
                 value: Box::new(OpSketch {
                     artifact_id: value.artifact_id,