Restore Lee's commit, without Cargo.lock changes

src/wasm-lib/grackle/Cargo.toml

@@ -6,6 +6,7 @@ description = "A new executor for KCL which compiles to Execution Plans"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+image = { version = "0.24.7", default-features = false, features = ["png"] }
 kcl-lib = { path = "../kcl" }
 kittycad = { workspace = true }
 kittycad-execution-plan = { workspace = true }
@@ -15,6 +16,7 @@ kittycad-modeling-cmds = { workspace = true }
 kittycad-modeling-session = { workspace = true }
 thiserror = "1.0.57"
 tokio = { version = "1.36.0", features = ["macros", "rt"] }
+twenty-twenty = "0.7.0"
 uuid = "1.7"
 
 [dev-dependencies]

src/wasm-lib/grackle/src/binding_scope.rs

@@ -113,6 +113,26 @@ impl BindingScope {
                     "lineTo".into(),
                     EpBinding::from(KclFunction::LineTo(native_functions::sketch::LineTo)),
                 ),
+                (
+                    "line".into(),
+                    EpBinding::from(KclFunction::Line(native_functions::sketch::Line)),
+                ),
+                (
+                    "xLineTo".into(),
+                    EpBinding::from(KclFunction::XLineTo(native_functions::sketch::XLineTo)),
+                ),
+                (
+                    "xLine".into(),
+                    EpBinding::from(KclFunction::XLine(native_functions::sketch::XLine)),
+                ),
+                (
+                    "yLineTo".into(),
+                    EpBinding::from(KclFunction::YLineTo(native_functions::sketch::YLineTo)),
+                ),
+                (
+                    "yLine".into(),
+                    EpBinding::from(KclFunction::YLine(native_functions::sketch::YLine)),
+                ),
                 (
                     "extrude".into(),
                     EpBinding::from(KclFunction::Extrude(native_functions::sketch::Extrude)),

src/wasm-lib/grackle/src/error.rs

@@ -76,7 +76,7 @@ impl From<ExecutionFailed> for Error {
     ) -> Self {
         Self::Execution {
             error,
-            instruction,
+            instruction: instruction.expect("no instruction"),
             instruction_index,
         }
     }

src/wasm-lib/grackle/src/lib.rs

@@ -262,6 +262,11 @@ impl Planner {
                     KclFunction::StartSketchAt(f) => f.call(&mut ctx, args)?,
                     KclFunction::Extrude(f) => f.call(&mut ctx, args)?,
                     KclFunction::LineTo(f) => f.call(&mut ctx, args)?,
+                    KclFunction::Line(f) => f.call(&mut ctx, args)?,
+                    KclFunction::XLineTo(f) => f.call(&mut ctx, args)?,
+                    KclFunction::XLine(f) => f.call(&mut ctx, args)?,
+                    KclFunction::YLineTo(f) => f.call(&mut ctx, args)?,
+                    KclFunction::YLine(f) => f.call(&mut ctx, args)?,
                     KclFunction::Add(f) => f.call(&mut ctx, args)?,
                     KclFunction::Close(f) => f.call(&mut ctx, args)?,
                     KclFunction::UserDefined(f) => {
@@ -631,6 +636,11 @@ enum KclFunction {
     Id(native_functions::Id),
     StartSketchAt(native_functions::sketch::StartSketchAt),
     LineTo(native_functions::sketch::LineTo),
+    Line(native_functions::sketch::Line),
+    XLineTo(native_functions::sketch::XLineTo),
+    XLine(native_functions::sketch::XLine),
+    YLineTo(native_functions::sketch::YLineTo),
+    YLine(native_functions::sketch::YLine),
     Add(native_functions::Add),
     UserDefined(UserDefinedFunction),
     Extrude(native_functions::sketch::Extrude),

src/wasm-lib/grackle/src/native_functions/sketch.rs

@@ -3,4 +3,4 @@
 pub mod helpers;
 pub mod stdlib_functions;
 
-pub use stdlib_functions::{Close, Extrude, LineTo, StartSketchAt};
+pub use stdlib_functions::{Close, Extrude, Line, LineTo, StartSketchAt, XLine, XLineTo, YLine, YLineTo};

src/wasm-lib/grackle/src/native_functions/sketch/helpers.rs

@@ -139,7 +139,7 @@ pub fn sequence_binding(
     }
 }
 
-/// Extract a 2D point from an argument to a Cabble.
+/// Extract a 2D point from an argument to a KCL Function.
 pub fn arg_point2d(
     arg: EpBinding,
     fn_name: &'static str,
@@ -148,7 +148,7 @@ pub fn arg_point2d(
     arg_number: usize,
 ) -> Result<Address, CompileError> {
     let expected = "2D point (array with length 2)";
-    let elements = sequence_binding(arg, "startSketchAt", "an array of length 2", arg_number)?;
+    let elements = sequence_binding(arg, fn_name, "an array of length 2", arg_number)?;
     if elements.len() != 2 {
         return Err(CompileError::ArgWrongType {
             fn_name,
@@ -165,12 +165,12 @@ pub fn arg_point2d(
     let start_z = start + 2;
     instructions.extend([
         Instruction::Copy {
-            source: single_binding(elements[0].clone(), "startSketchAt", "number", arg_number)?,
+            source: single_binding(elements[0].clone(), fn_name, "number", arg_number)?,
             destination: Destination::Address(start_x),
             length: 1,
         },
         Instruction::Copy {
-            source: single_binding(elements[1].clone(), "startSketchAt", "number", arg_number)?,
+            source: single_binding(elements[1].clone(), fn_name, "number", arg_number)?,
             destination: Destination::Address(start_y),
             length: 1,
         },