Cut release v0.9.3 (#753 )

Request a feature should open externally (#737 )
Fixes #659
2023-10-02 14:14:00 -04:00 · 2023-10-02 13:26:23 -04:00 · 2023-10-02 09:50:49 -04:00 · 2023-09-30 12:24:39 +10:00 · 2023-09-29 22:19:20 -04:00 · 2023-09-29 14:41:14 -07:00
118 changed files with 6853 additions and 2422 deletions
--- a/.github/workflows/cargo-test.yml
+++ b/.github/workflows/cargo-test.yml
@ -58,4 +58,5 @@ jobs:
          cargo nextest run --workspace --no-fail-fast -P ci
        env:
          KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN}}
+          RUST_MIN_STACK: 10485760000

--- a/.gitignore
+++ b/.gitignore
@ -22,7 +22,10 @@ npm-debug.log*
 yarn-debug.log*
 yarn-error.log*

+.idea
+.vscode
 src/wasm-lib/.idea
+src/wasm-lib/.vscode

 # rust
 src/wasm-lib/target
--- a/README.md
+++ b/README.md
@ -123,13 +123,24 @@ Before you submit a contribution PR to this repo, please ensure that:

 ## Release a new version

-1. Bump the versions in the .json files by creating a `Bump to v{x}.{y}.{z}` PR, committing the changes from
+1. Bump the versions in the .json files by creating a `Cut release v{x}.{y}.{z}` PR, committing the changes from

 ```bash
 VERSION=x.y.z yarn run bump-jsons
 ```

-The PR may serve as a place to discuss the human-readable changelog and extra QA.
+The PR may serve as a place to discuss the human-readable changelog and extra QA. A quick way of getting PR's merged since the last bump is to [use this PR filter](https://github.com/KittyCAD/modeling-app/pulls?q=is%3Apr+sort%3Aupdated-desc+is%3Amerged+), open up the browser console and past in the following
+
+```typescript
+console.log(
+  '- ' +
+    Array.from(
+      document.querySelectorAll('[data-hovercard-type="pull_request"]')
+    ).map((a) => `[${a.innerText}](${a.href})`).join(`
+- `)
+)
+```
+grab the md list and delete any that are older than the last bump

 2. Merge the PR

--- a/docs/kcl/std.json
+++ b/docs/kcl/std.json
--- a/docs/kcl/std.md
+++ b/docs/kcl/std.md
@ -50,6 +50,8 @@
 	* [`sqrt`](#sqrt)
 	* [`startSketchAt`](#startSketchAt)
 	* [`tan`](#tan)
+	* [`tangentalArc`](#tangentalArc)
+	* [`tangentalArcTo`](#tangentalArcTo)
 	* [`tau`](#tau)
 	* [`xLine`](#xLine)
 	* [`xLineTo`](#xLineTo)
@ -3234,6 +3236,320 @@ tan(num: number) -> number



+### tangentalArc
+
+Draw an arc.
+
+
+
+```
+tangentalArc(data: TangentalArcData, sketch_group: SketchGroup) -> SketchGroup
+```
+
+#### Arguments
+
+* `data`: `TangentalArcData` - Data to draw a tangental arc.
+```
+{
+	// Offset of the arc, in degrees.
+	offset: number,
+	// Radius of the arc. Not to be confused with Raiders of the Lost Ark.
+	radius: number,
+} |
+{
+	// The tag.
+	tag: string,
+	// Where the arc should end. Must lie in the same plane as the current path pen position. Must not be colinear with current path pen position.
+	to: [number],
+} |
+[number]
+```
+* `sketch_group`: `SketchGroup` - A sketch group is a collection of paths.
+```
+{
+	// The id of the sketch group.
+	id: uuid,
+	// The position of the sketch group.
+	position: [number],
+	// The rotation of the sketch group.
+	rotation: [number],
+	// The starting path.
+	start: {
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+},
+	// The paths in the sketch group.
+	value: [{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+	// The y coordinate.
+	y: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+}],
+}
+```
+
+#### Returns
+
+* `SketchGroup` - A sketch group is a collection of paths.
+```
+{
+	// The id of the sketch group.
+	id: uuid,
+	// The position of the sketch group.
+	position: [number],
+	// The rotation of the sketch group.
+	rotation: [number],
+	// The starting path.
+	start: {
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+},
+	// The paths in the sketch group.
+	value: [{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+	// The y coordinate.
+	y: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+}],
+}
+```
+
+
+
+### tangentalArcTo
+
+Draw an arc.
+
+
+
+```
+tangentalArcTo(data: TangentalArcToData, sketch_group: SketchGroup) -> SketchGroup
+```
+
+#### Arguments
+
+* `data`: `TangentalArcToData` - Data to draw a tangental arc to a specific point.
+```
+{
+	// The tag.
+	tag: string,
+	// Where the arc should end. Must lie in the same plane as the current path pen position. Must not be colinear with current path pen position.
+	to: [number],
+} |
+[number]
+```
+* `sketch_group`: `SketchGroup` - A sketch group is a collection of paths.
+```
+{
+	// The id of the sketch group.
+	id: uuid,
+	// The position of the sketch group.
+	position: [number],
+	// The rotation of the sketch group.
+	rotation: [number],
+	// The starting path.
+	start: {
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+},
+	// The paths in the sketch group.
+	value: [{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+	// The y coordinate.
+	y: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+}],
+}
+```
+
+#### Returns
+
+* `SketchGroup` - A sketch group is a collection of paths.
+```
+{
+	// The id of the sketch group.
+	id: uuid,
+	// The position of the sketch group.
+	position: [number],
+	// The rotation of the sketch group.
+	rotation: [number],
+	// The starting path.
+	start: {
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+},
+	// The paths in the sketch group.
+	value: [{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+	// The x coordinate.
+	x: number,
+	// The y coordinate.
+	y: number,
+} |
+{
+	// The from point.
+	from: [number],
+	// The name of the path.
+	name: string,
+	// The to point.
+	to: [number],
+	type: string,
+}],
+}
+```
+
+
+
 ### tau

 Return the value of `tau`. The full circle constant (τ). Equal to 2π.
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "untitled-app",
-  "version": "0.8.2",
+  "version": "0.9.3",
  "private": true,
  "dependencies": {
    "@codemirror/autocomplete": "^6.9.0",
@ -10,7 +10,7 @@
    "@fortawesome/react-fontawesome": "^0.2.0",
    "@headlessui/react": "^1.7.13",
    "@headlessui/tailwindcss": "^0.2.0",
-    "@kittycad/lib": "^0.0.37",
+    "@kittycad/lib": "^0.0.40",
    "@lezer/javascript": "^1.4.7",
    "@open-rpc/client-js": "^1.8.1",
    "@react-hook/resize-observer": "^1.2.6",
@ -27,6 +27,7 @@
    "@uiw/react-codemirror": "^4.21.13",
    "@xstate/react": "^3.2.2",
    "crypto-js": "^4.1.1",
+    "debounce-promise": "^3.1.2",
    "formik": "^2.4.3",
    "fuse.js": "^6.6.2",
    "http-server": "^14.1.1",
@ -47,7 +48,7 @@
    "ts-node": "^10.9.1",
    "typescript": "^4.4.2",
    "uuid": "^9.0.0",
-    "vitest": "^0.34.1",
+    "vitest": "^0.34.6",
    "vscode-jsonrpc": "^8.1.0",
    "vscode-languageserver-protocol": "^3.17.3",
    "wasm-pack": "^0.12.1",
@ -101,7 +102,7 @@
    "@babel/preset-env": "^7.22.9",
    "@tauri-apps/cli": "^1.3.1",
    "@types/crypto-js": "^4.1.1",
-    "@types/debounce": "^1.2.1",
+    "@types/debounce-promise": "^3.1.6",
    "@types/isomorphic-fetch": "^0.0.36",
    "@types/react-modal": "^3.16.0",
    "@types/uuid": "^9.0.1",
@ -115,7 +116,7 @@
    "eslint-plugin-css-modules": "^2.11.0",
    "happy-dom": "^10.8.0",
    "husky": "^8.0.3",
-    "postcss": "^8.4.19",
+    "postcss": "^8.4.31",
    "prettier": "^2.8.0",
    "setimmediate": "^1.0.5",
    "tailwindcss": "^3.2.4",
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@ -84,7 +84,7 @@ dependencies = [
 "tauri-build",
 "tauri-plugin-fs-extra",
 "tokio",
- "toml 0.8.0",
+ "toml 0.8.1",
 ]

 [[package]]
@ -155,6 +155,20 @@ version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d"

+[[package]]
+name = "bigdecimal"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "454bca3db10617b88b566f205ed190aedb0e0e6dd4cad61d3988a72e8c5594cb"
+dependencies = [
+ "autocfg",
+ "libm",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "serde",
+]
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@ -1295,7 +1309,21 @@ checksum = "e5c13fb08e5d4dfc151ee5e88bae63f7773d61852f3bdc73c9f4b9e1bde03148"
 dependencies = [
 "log",
 "mac",
- "markup5ever",
+ "markup5ever 0.10.1",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "html5ever"
+version = "0.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bea68cab48b8459f17cf1c944c67ddc572d272d9f2b274140f223ecb1da4a3b7"
+dependencies = [
+ "log",
+ "mac",
+ "markup5ever 0.11.0",
 "proc-macro2",
 "quote",
 "syn 1.0.109",
@ -1630,13 +1658,14 @@ dependencies = [

 [[package]]
 name = "kittycad"
-version = "0.2.25"
+version = "0.2.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9cf962b1e81a0b4eb923a727e761b40672cbacc7f5f0b75e13579d346352bc7"
+checksum = "35b2f9302648dbb06fd7121687f9505fc3179eba84111a06d76b246e3158f5dc"
 dependencies = [
 "anyhow",
 "async-trait",
 "base64 0.21.2",
+ "bigdecimal",
 "bytes",
 "chrono",
 "data-encoding",
@ -1671,7 +1700,20 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1ea8e9c6e031377cff82ee3001dc8026cdf431ed4e2e6b51f98ab8c73484a358"
 dependencies = [
 "cssparser",
- "html5ever",
+ "html5ever 0.25.2",
+ "matches",
+ "selectors",
+]
+
+[[package]]
+name = "kuchikiki"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f29e4755b7b995046f510a7520c42b2fed58b77bd94d5a87a8eb43d2fd126da8"
+dependencies = [
+ "cssparser",
+ "html5ever 0.26.0",
+ "indexmap 1.9.3",
 "matches",
 "selectors",
 ]
@ -1688,6 +1730,12 @@ version = "0.2.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"

+[[package]]
+name = "libm"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+
 [[package]]
 name = "line-wrap"
 version = "0.1.1"
@ -1727,9 +1775,9 @@ dependencies = [

 [[package]]
 name = "log"
-version = "0.4.18"
+version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "518ef76f2f87365916b142844c16d8fefd85039bc5699050210a7778ee1cd1de"
+checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 dependencies = [
 "serde",
 ]
@ -1781,7 +1829,21 @@ checksum = "a24f40fb03852d1cdd84330cddcaf98e9ec08a7b7768e952fad3b4cf048ec8fd"
 dependencies = [
 "log",
 "phf 0.8.0",
- "phf_codegen",
+ "phf_codegen 0.8.0",
+ "string_cache",
+ "string_cache_codegen",
+ "tendril",
+]
+
+[[package]]
+name = "markup5ever"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2629bb1404f3d34c2e921f21fd34ba00b206124c81f65c50b43b6aaefeb016"
+dependencies = [
+ "log",
+ "phf 0.10.1",
+ "phf_codegen 0.10.0",
 "string_cache",
 "string_cache_codegen",
 "tendril",
@ -1959,6 +2021,17 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.45"
@ -1982,9 +2055,9 @@ dependencies = [

 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
 dependencies = [
 "autocfg",
 ]
@ -2342,6 +2415,16 @@ dependencies = [
 "phf_shared 0.8.0",
 ]

+[[package]]
+name = "phf_codegen"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fb1c3a8bc4dd4e5cfce29b44ffc14bedd2ee294559a294e2a4d4c9e9a6a13cd"
+dependencies = [
+ "phf_generator 0.10.0",
+ "phf_shared 0.10.0",
+]
+
 [[package]]
 name = "phf_generator"
 version = "0.8.0"
@ -2410,9 +2493,9 @@ dependencies = [

 [[package]]
 name = "phonenumber"
-version = "0.3.2+8.13.9"
+version = "0.3.3+8.13.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34749f64ea9d76f10cdc8a859588b57775f59177c7dd91f744d620bd62982d6f"
+checksum = "635f3e6288e4f01c049d89332a031bd74f25d64b6fb94703ca966e819488cd06"
 dependencies = [
 "bincode",
 "either",
@ -2425,6 +2508,7 @@ dependencies = [
 "regex-cache",
 "serde",
 "serde_derive",
+ "strum",
 "thiserror",
 ]

@ -3021,10 +3105,11 @@ dependencies = [

 [[package]]
 name = "schemars"
-version = "0.8.13"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "763f8cd0d4c71ed8389c90cb8100cba87e763bd01a8e614d4f0af97bcd50a161"
+checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c"
 dependencies = [
+ "bigdecimal",
 "bytes",
 "chrono",
 "dyn-clone",
@ -3037,9 +3122,9 @@ dependencies = [

 [[package]]
 name = "schemars_derive"
-version = "0.8.13"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0f696e21e10fa546b7ffb1c9672c6de8fbc7a81acf59524386d8639bf12737"
+checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c"
 dependencies = [
 "proc-macro2",
 "quote",
@ -3105,7 +3190,7 @@ dependencies = [
 "log",
 "matches",
 "phf 0.8.0",
- "phf_codegen",
+ "phf_codegen 0.8.0",
 "precomputed-hash",
 "servo_arc",
 "smallvec",
@ -3458,6 +3543,28 @@ dependencies = [
 "syn 2.0.33",
 ]

+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@ -3605,9 +3712,9 @@ dependencies = [

 [[package]]
 name = "tauri"
-version = "1.4.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fbe522898e35407a8e60dc3870f7579fea2fc262a6a6072eccdd37ae1e1d91e"
+checksum = "72aee3277d0a0df01472cc704ab5934a51a1f25348838df17bfb3c5cb727880c"
 dependencies = [
 "anyhow",
 "base64 0.21.2",
@ -3661,12 +3768,13 @@ dependencies = [

 [[package]]
 name = "tauri-build"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d2edd6a259b5591c8efdeb9d5702cb53515b82a6affebd55c7fd6d3a27b7d1b"
+checksum = "6a62b3327886e7ef2978adc668432f1cc53f14e1d46e7ae04f730f4d48584623"
 dependencies = [
 "anyhow",
 "cargo_toml",
+ "dirs-next",
 "heck 0.4.1",
 "json-patch",
 "semver",
@ -3674,13 +3782,14 @@ dependencies = [
 "serde_json",
 "tauri-utils",
 "tauri-winres",
+ "walkdir",
 ]

 [[package]]
 name = "tauri-codegen"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54ad2d49fdeab4a08717f5b49a163bdc72efc3b1950b6758245fcde79b645e1a"
+checksum = "7b3475e55acec0b4a50fb96435f19631fb58cbcd31923e1a213de5c382536bbb"
 dependencies = [
 "base64 0.21.2",
 "brotli",
@ -3704,9 +3813,9 @@ dependencies = [

 [[package]]
 name = "tauri-macros"
-version = "1.4.0"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8eb12a2454e747896929338d93b0642144bb51e0dddbb36e579035731f0d76b7"
+checksum = "613740228de92d9196b795ac455091d3a5fbdac2654abb8bb07d010b62ab43af"
 dependencies = [
 "heck 0.4.1",
 "proc-macro2",
@ -3719,7 +3828,7 @@ dependencies = [
 [[package]]
 name = "tauri-plugin-fs-extra"
 version = "0.0.0"
-source = "git+https://github.com/tauri-apps/plugins-workspace?branch=v1#5b814f56e6368fdec46c4ddb04a07e0923ff995a"
+source = "git+https://github.com/tauri-apps/plugins-workspace?branch=v1#9af4c3727c0d9c7a88b27cb80a6482a5aa461fc5"
 dependencies = [
 "log",
 "serde",
@ -3730,9 +3839,9 @@ dependencies = [

 [[package]]
 name = "tauri-runtime"
-version = "0.14.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "108683199cb18f96d2d4134187bb789964143c845d2d154848dda209191fd769"
+checksum = "07f8e9e53e00e9f41212c115749e87d5cd2a9eebccafca77a19722eeecd56d43"
 dependencies = [
 "gtk",
 "http",
@ -3751,9 +3860,9 @@ dependencies = [

 [[package]]
 name = "tauri-runtime-wry"
-version = "0.14.0"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7aa256a1407a3a091b5d843eccc1a5042289baf0a43d1179d9f0fcfea37c1b"
+checksum = "8141d72b6b65f2008911e9ef5b98a68d1e3413b7a1464e8f85eb3673bb19a895"
 dependencies = [
 "cocoa",
 "gtk",
@ -3771,19 +3880,20 @@ dependencies = [

 [[package]]
 name = "tauri-utils"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03fc02bb6072bb397e1d473c6f76c953cda48b4a2d0cce605df284aa74a12e84"
+checksum = "34d55e185904a84a419308d523c2c6891d5e2dbcee740c4997eb42e75a7b0f46"
 dependencies = [
 "brotli",
 "ctor",
 "dunce",
 "glob",
 "heck 0.4.1",
- "html5ever",
+ "html5ever 0.26.0",
 "infer",
 "json-patch",
- "kuchiki",
+ "kuchikiki",
+ "log",
 "memchr",
 "phf 0.10.1",
 "proc-macro2",
@ -3968,14 +4078,14 @@ dependencies = [

 [[package]]
 name = "toml"
-version = "0.8.0"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c226a7bba6d859b63c92c4b4fe69c5b6b72d0cb897dbc8e6012298e6154cb56e"
+checksum = "1bc1433177506450fe920e46a4f9812d0c211f5dd556da10e731a0a3dfa151f0"
 dependencies = [
 "serde",
 "serde_spanned",
 "toml_datetime",
- "toml_edit 0.20.0",
+ "toml_edit 0.20.1",
 ]

 [[package]]
@ -4002,9 +4112,9 @@ dependencies = [

 [[package]]
 name = "toml_edit"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ff63e60a958cefbb518ae1fd6566af80d9d4be430a33f3723dfc47d1d411d95"
+checksum = "ca676d9ba1a322c1b64eb8045a5ec5c0cfb0c9d08e15e9ff622589ad5221c8fe"
 dependencies = [
 "indexmap 2.0.0",
 "serde",
@ -4799,9 +4909,9 @@ dependencies = [

 [[package]]
 name = "wry"
-version = "0.24.3"
+version = "0.24.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33748f35413c8a98d45f7a08832d848c0c5915501803d1faade5a4ebcd258cea"
+checksum = "88ef04bdad49eba2e01f06e53688c8413bd6a87b0bc14b72284465cf96e3578e"
 dependencies = [
 "base64 0.13.1",
 "block",
@ -4813,7 +4923,7 @@ dependencies = [
 "gio",
 "glib",
 "gtk",
- "html5ever",
+ "html5ever 0.25.2",
 "http",
 "kuchiki",
 "libc",
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@ -12,18 +12,18 @@ rust-version = "1.60"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

 [build-dependencies]
-tauri-build = { version = "1.4.0", features = [] }
+tauri-build = { version = "1.4.1", features = [] }

 [dependencies]
 anyhow = "1"
-kittycad = "0.2.25"
+kittycad = "0.2.28"
 oauth2 = "4.4.2"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
-tauri = { version = "1.4.1", features = [ "os-all", "dialog-all", "fs-all", "http-request", "path-all", "shell-open", "shell-open-api", "updater", "devtools"] }
+tauri = { version = "1.5.0", features = [ "os-all", "dialog-all", "fs-all", "http-request", "path-all", "shell-open", "shell-open-api", "updater", "devtools"] }
 tauri-plugin-fs-extra = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
 tokio = { version = "1.32.0", features = ["time"] }
-toml = "0.8.0"
+toml = "0.8.1"

 [features]
 # this feature is used for production builds or when `devPath` points to the filesystem and the built-in dev server is disabled.
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@ -8,7 +8,7 @@
  },
  "package": {
    "productName": "kittycad-modeling",
-    "version": "0.8.2"
+    "version": "0.9.3"
  },
  "tauri": {
    "allowlist": {
--- a/src/App.tsx
+++ b/src/App.tsx
@ -31,6 +31,7 @@ import { TextEditor } from 'components/TextEditor'
 import { Themes, getSystemTheme } from 'lib/theme'
 import { useSetupEngineManager } from 'hooks/useSetupEngineManager'
 import { useEngineConnectionSubscriptions } from 'hooks/useEngineConnectionSubscriptions'
+import { engineCommandManager } from './lang/std/engineConnection'

 export function App() {
  const { code: loadedCode, project } = useLoaderData() as IndexLoaderData
@ -39,7 +40,6 @@ export function App() {
  useHotKeyListener()
  const {
    setCode,
-    engineCommandManager,
    buttonDownInStream,
    openPanes,
    setOpenPanes,
@ -52,7 +52,6 @@ export function App() {
    guiMode: s.guiMode,
    setGuiMode: s.setGuiMode,
    setCode: s.setCode,
-    engineCommandManager: s.engineCommandManager,
    buttonDownInStream: s.buttonDownInStream,
    openPanes: s.openPanes,
    setOpenPanes: s.setOpenPanes,
@ -91,12 +90,12 @@ export function App() {
      if (guiMode.sketchMode === 'sketchEdit') {
        // TODO: share this with Toolbar's "Exit sketch" button
        // exiting sketch should be done consistently across all exits
-        engineCommandManager?.sendSceneCommand({
+        engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: { type: 'edit_mode_exit' },
        })
-        engineCommandManager?.sendSceneCommand({
+        engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: { type: 'default_camera_disable_sketch_mode' },
@ -107,7 +106,7 @@ export function App() {
        // when exiting sketch mode in the future
        executeAst()
      } else {
-        engineCommandManager?.sendSceneCommand({
+        engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: {
@ -156,7 +155,7 @@ export function App() {
  useEngineConnectionSubscriptions()

  const debounceSocketSend = throttle<EngineCommand>((message) => {
-    engineCommandManager?.sendSceneCommand(message)
+    engineCommandManager.sendSceneCommand(message)
  }, 16)
  const handleMouseMove: MouseEventHandler<HTMLDivElement> = (e) => {
    e.nativeEvent.preventDefault()
@ -216,7 +215,6 @@ export function App() {
      } else if (interactionGuards.zoom.dragCallback(eWithButton)) {
        interaction = 'zoom'
      } else {
-        console.log('none')
        return
      }

--- a/src/Toolbar.tsx
+++ b/src/Toolbar.tsx
@ -18,6 +18,7 @@ import styles from './Toolbar.module.css'
 import { v4 as uuidv4 } from 'uuid'
 import { useAppMode } from 'hooks/useAppMode'
 import { ActionIcon } from 'components/ActionIcon'
+import { engineCommandManager } from './lang/std/engineConnection'

 export const sketchButtonClassnames = {
  background:
@ -50,7 +51,6 @@ export const Toolbar = () => {
    ast,
    updateAst,
    programMemory,
-    engineCommandManager,
    executeAst,
  } = useStore((s) => ({
    guiMode: s.guiMode,
@ -59,15 +59,10 @@ export const Toolbar = () => {
    ast: s.ast,
    updateAst: s.updateAst,
    programMemory: s.programMemory,
-    engineCommandManager: s.engineCommandManager,
    executeAst: s.executeAst,
  }))
  useAppMode()

-  useEffect(() => {
-    console.log('guiMode', guiMode)
-  }, [guiMode])
-
  function ToolbarButtons({ className }: React.HTMLAttributes<HTMLElement>) {
    return (
      <span className={styles.toolbarButtons + ' ' + className}>
@ -173,12 +168,12 @@ export const Toolbar = () => {
        {guiMode.mode === 'sketch' && (
          <button
            onClick={() => {
-              engineCommandManager?.sendSceneCommand({
+              engineCommandManager.sendSceneCommand({
                type: 'modeling_cmd_req',
                cmd_id: uuidv4(),
                cmd: { type: 'edit_mode_exit' },
              })
-              engineCommandManager?.sendSceneCommand({
+              engineCommandManager.sendSceneCommand({
                type: 'modeling_cmd_req',
                cmd_id: uuidv4(),
                cmd: { type: 'default_camera_disable_sketch_mode' },
@ -214,7 +209,7 @@ export const Toolbar = () => {
              <button
                key={sketchFnName}
                onClick={() => {
-                  engineCommandManager?.sendSceneCommand({
+                  engineCommandManager.sendSceneCommand({
                    type: 'modeling_cmd_req',
                    cmd_id: uuidv4(),
                    cmd: {
--- a/src/components/ActionButton.tsx
+++ b/src/components/ActionButton.tsx
@ -23,10 +23,7 @@ type ActionButtonAsLink = BaseActionButtonProps &
  }

 type ActionButtonAsExternal = BaseActionButtonProps &
-  Omit<
-    React.AnchorHTMLAttributes<HTMLAnchorElement>,
-    keyof BaseActionButtonProps
-  > & {
+  Omit<LinkProps, keyof BaseActionButtonProps> & {
    Element: 'externalLink'
  }

@ -69,12 +66,17 @@ export const ActionButton = (props: ActionButtonProps) => {
      )
    }
    case 'externalLink': {
-      const { Element, icon, children, className, ...rest } = props
+      const { Element, to, icon, children, className, ...rest } = props
      return (
-        <a className={classNames} {...rest}>
+        <Link
+          to={to || paths.INDEX}
+          className={classNames}
+          {...rest}
+          target="_blank"
+        >
          {icon && <ActionIcon {...icon} />}
          {children}
-        </a>
+        </Link>
      )
    }
    default: {
--- a/src/components/AvailableVarsHelpers.tsx
+++ b/src/components/AvailableVarsHelpers.tsx
@ -1,7 +1,5 @@
 import { useEffect, useState, useRef } from 'react'
-import { parser_wasm } from '../lang/abstractSyntaxTree'
-import { BinaryPart, Value } from '../lang/abstractSyntaxTreeTypes'
-import { executor } from '../lang/executor'
+import { parse, BinaryPart, Value, executor } from '../lang/wasm'
 import {
  createIdentifier,
  createLiteral,
@ -10,6 +8,7 @@ import {
 } from '../lang/modifyAst'
 import { findAllPreviousVariables, PrevVariable } from '../lang/queryAst'
 import { useStore } from '../useStore'
+import { engineCommandManager } from '../lang/std/engineConnection'

 export const AvailableVars = ({
  onVarClick,
@ -92,14 +91,11 @@ export function useCalc({
  newVariableInsertIndex: number
  setNewVariableName: (a: string) => void
 } {
-  const { ast, programMemory, selectionRange, engineCommandManager } = useStore(
-    (s) => ({
-      ast: s.ast,
-      programMemory: s.programMemory,
-      selectionRange: s.selectionRanges.codeBasedSelections[0].range,
-      engineCommandManager: s.engineCommandManager,
-    })
-  )
+  const { ast, programMemory, selectionRange } = useStore((s) => ({
+    ast: s.ast,
+    programMemory: s.programMemory,
+    selectionRange: s.selectionRanges.codeBasedSelections[0].range,
+  }))
  const inputRef = useRef<HTMLInputElement>(null)
  const [availableVarInfo, setAvailableVarInfo] = useState<
    ReturnType<typeof findAllPreviousVariables>
@ -140,10 +136,9 @@ export function useCalc({
  }, [ast, programMemory, selectionRange])

  useEffect(() => {
-    if (!engineCommandManager) return
    try {
      const code = `const __result__ = ${value}\nshow(__result__)`
-      const ast = parser_wasm(code)
+      const ast = parse(code)
      const _programMem: any = { root: {}, return: null }
      availableVarInfo.variables.forEach(({ key, value }) => {
        _programMem.root[key] = { type: 'userVal', value, __meta: [] }
--- a/src/components/DebugPanel.tsx
+++ b/src/components/DebugPanel.tsx
@ -1,5 +1,4 @@
 import { CollapsiblePanel, CollapsiblePanelProps } from './CollapsiblePanel'
-import { useStore } from '../useStore'
 import { v4 as uuidv4 } from 'uuid'
 import { EngineCommand } from '../lang/std/engineConnection'
 import { useState } from 'react'
@ -7,6 +6,7 @@ import { ActionButton } from '../components/ActionButton'
 import { faCheck } from '@fortawesome/free-solid-svg-icons'
 import { isReducedMotion } from 'lang/util'
 import { AstExplorer } from './AstExplorer'
+import { engineCommandManager } from '../lang/std/engineConnection'

 type SketchModeCmd = Extract<
  Extract<EngineCommand, { type: 'modeling_cmd_req' }>['cmd'],
@ -14,9 +14,6 @@ type SketchModeCmd = Extract<
 >

 export const DebugPanel = ({ className, ...props }: CollapsiblePanelProps) => {
-  const { engineCommandManager } = useStore((s) => ({
-    engineCommandManager: s.engineCommandManager,
-  }))
  const [sketchModeCmd, setSketchModeCmd] = useState<SketchModeCmd>({
    type: 'default_camera_enable_sketch_mode',
    origin: { x: 0, y: 0, z: 0 },
@ -70,19 +67,18 @@ export const DebugPanel = ({ className, ...props }: CollapsiblePanelProps) => {
            className="w-16"
            type="checkbox"
            checked={sketchModeCmd.ortho}
-            onChange={(a) => {
-              console.log(a, (a as any).checked)
+            onChange={(a) =>
              setSketchModeCmd({
                ...sketchModeCmd,
                ortho: a.target.checked,
              })
-            }}
+            }
          />
        </div>
        <ActionButton
          Element="button"
          onClick={() => {
-            engineCommandManager?.sendSceneCommand({
+            engineCommandManager.sendSceneCommand({
              type: 'modeling_cmd_req',
              cmd: sketchModeCmd,
              cmd_id: uuidv4(),
--- a/src/components/ExportButton.tsx
+++ b/src/components/ExportButton.tsx
@ -1,13 +1,17 @@
 import { v4 as uuidv4 } from 'uuid'
-import { useStore } from '../useStore'
 import { faFileExport, faXmark } from '@fortawesome/free-solid-svg-icons'
 import { ActionButton } from './ActionButton'
 import Modal from 'react-modal'
 import React from 'react'
 import { useFormik } from 'formik'
 import { Models } from '@kittycad/lib'
+import { engineCommandManager } from '../lang/std/engineConnection'
+import { useGlobalStateContext } from 'hooks/useGlobalStateContext'

 type OutputFormat = Models['OutputFormat_type']
+type OutputTypeKey = OutputFormat['type']
+type ExtractStorageTypes<T> = T extends { storage: infer U } ? U : never
+type StorageUnion = ExtractStorageTypes<OutputFormat>

 interface ExportButtonProps extends React.PropsWithChildren {
  className?: {
@ -18,14 +22,19 @@ interface ExportButtonProps extends React.PropsWithChildren {
 }

 export const ExportButton = ({ children, className }: ExportButtonProps) => {
-  const { engineCommandManager } = useStore((s) => ({
-    engineCommandManager: s.engineCommandManager,
-  }))
-
  const [modalIsOpen, setIsOpen] = React.useState(false)
+  const {
+    settings: {
+      state: {
+        context: { baseUnit },
+      },
+    },
+  } = useGlobalStateContext()

  const defaultType = 'gltf'
-  const [type, setType] = React.useState(defaultType)
+  const [type, setType] = React.useState<OutputTypeKey>(defaultType)
+  const defaultStorage = 'embedded'
+  const [storage, setStorage] = React.useState<StorageUnion>(defaultStorage)

  function openModal() {
    setIsOpen(true)
@ -38,7 +47,7 @@ export const ExportButton = ({ children, className }: ExportButtonProps) => {
  // Default to gltf and embedded.
  const initialValues: OutputFormat = {
    type: defaultType,
-    storage: 'embedded',
+    storage: defaultStorage,
    presentation: 'pretty',
  }
  const formik = useFormik({
@ -66,7 +75,18 @@ export const ExportButton = ({ children, className }: ExportButtonProps) => {
          },
        }
      }
-      engineCommandManager?.sendSceneCommand({
+      if (values.type === 'obj' || values.type === 'stl') {
+        values.units = baseUnit
+      }
+      if (
+        values.type === 'ply' ||
+        values.type === 'stl' ||
+        values.type === 'gltf'
+      ) {
+        // Set the storage type.
+        values.storage = storage
+      }
+      engineCommandManager.sendSceneCommand({
        type: 'modeling_cmd_req',
        cmd: {
          type: 'export',
@ -75,6 +95,7 @@ export const ExportButton = ({ children, className }: ExportButtonProps) => {
          // in the scene to export. In that case, you'd pass the IDs thru here.
          entity_ids: [],
          format: values,
+          source_unit: baseUnit,
        },
        cmd_id: uuidv4(),
      })
@ -109,7 +130,17 @@ export const ExportButton = ({ children, className }: ExportButtonProps) => {
                id="type"
                name="type"
                onChange={(e) => {
-                  setType(e.target.value)
+                  setType(e.target.value as OutputTypeKey)
+                  if (e.target.value === 'gltf') {
+                    // Set default to embedded.
+                    setStorage('embedded')
+                  } else if (e.target.value === 'ply') {
+                    // Set default to ascii.
+                    setStorage('ascii')
+                  } else if (e.target.value === 'stl') {
+                    // Set default to ascii.
+                    setStorage('ascii')
+                  }
                  formik.handleChange(e)
                }}
                className="bg-chalkboard-20 dark:bg-chalkboard-90 w-full"
@ -127,10 +158,10 @@ export const ExportButton = ({ children, className }: ExportButtonProps) => {
                <select
                  id="storage"
                  name="storage"
-                  onChange={formik.handleChange}
-                  value={
-                    'storage' in formik.values ? formik.values.storage : ''
-                  }
+                  onChange={(e) => {
+                    setStorage(e.target.value as StorageUnion)
+                    formik.handleChange(e)
+                  }}
                  className="bg-chalkboard-20 dark:bg-chalkboard-90 w-full"
                >
                  {type === 'gltf' && (
--- a/src/components/MemoryPanel.test.tsx
+++ b/src/components/MemoryPanel.test.tsx
@ -1,7 +1,6 @@
 import { processMemory } from './MemoryPanel'
-import { parser_wasm } from '../lang/abstractSyntaxTree'
 import { enginelessExecutor } from '../lib/testHelpers'
-import { initPromise } from '../lang/rust'
+import { initPromise, parse } from '../lang/wasm'

 beforeAll(() => initPromise)

@ -26,7 +25,7 @@ describe('processMemory', () => {
    |> lineTo([2.15, 4.32], %)
    // |> rx(90, %)
  show(theExtrude, theSketch)`
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast, {
      root: {},
      return: null,
--- a/src/components/MemoryPanel.tsx
+++ b/src/components/MemoryPanel.tsx
@ -2,7 +2,7 @@ import ReactJson from 'react-json-view'
 import { CollapsiblePanel, CollapsiblePanelProps } from './CollapsiblePanel'
 import { useStore } from '../useStore'
 import { useMemo } from 'react'
-import { ProgramMemory, Path, ExtrudeSurface } from '../lang/executor'
+import { ProgramMemory, Path, ExtrudeSurface } from '../lang/wasm'
 import { Themes } from '../lib/theme'

 interface MemoryPanelProps extends CollapsiblePanelProps {
@ -50,7 +50,7 @@ export const MemoryPanel = ({

 export const processMemory = (programMemory: ProgramMemory) => {
  const processedMemory: any = {}
-  Object.keys(programMemory.root).forEach((key) => {
+  Object.keys(programMemory?.root || {}).forEach((key) => {
    const val = programMemory.root[key]
    if (typeof val.value !== 'function') {
      if (val.type === 'SketchGroup') {
--- a/src/components/ProjectSidebarMenu.test.tsx
+++ b/src/components/ProjectSidebarMenu.test.tsx
@ -2,6 +2,8 @@ import { fireEvent, render, screen } from '@testing-library/react'
 import { BrowserRouter } from 'react-router-dom'
 import ProjectSidebarMenu from './ProjectSidebarMenu'
 import { ProjectWithEntryPointMetadata } from '../Router'
+import { GlobalStateProvider } from './GlobalStateProvider'
+import CommandBarProvider from './CommandBar'

 const now = new Date()
 const projectWellFormed = {
@ -38,7 +40,11 @@ describe('ProjectSidebarMenu tests', () => {
  test('Renders the project name', () => {
    render(
      <BrowserRouter>
-        <ProjectSidebarMenu project={projectWellFormed} />
+        <CommandBarProvider>
+          <GlobalStateProvider>
+            <ProjectSidebarMenu project={projectWellFormed} />
+          </GlobalStateProvider>
+        </CommandBarProvider>
      </BrowserRouter>
    )

@ -55,7 +61,11 @@ describe('ProjectSidebarMenu tests', () => {
  test('Renders app name if given no project', () => {
    render(
      <BrowserRouter>
-        <ProjectSidebarMenu />
+        <CommandBarProvider>
+          <GlobalStateProvider>
+            <ProjectSidebarMenu />
+          </GlobalStateProvider>
+        </CommandBarProvider>
      </BrowserRouter>
    )

@ -69,7 +79,14 @@ describe('ProjectSidebarMenu tests', () => {
  test('Renders as a link if set to do so', () => {
    render(
      <BrowserRouter>
-        <ProjectSidebarMenu project={projectWellFormed} renderAsLink={true} />
+        <CommandBarProvider>
+          <GlobalStateProvider>
+            <ProjectSidebarMenu
+              project={projectWellFormed}
+              renderAsLink={true}
+            />
+          </GlobalStateProvider>
+        </CommandBarProvider>
      </BrowserRouter>
    )

--- a/src/components/SetAngleLengthModal.tsx
+++ b/src/components/SetAngleLengthModal.tsx
@ -1,6 +1,6 @@
 import { Dialog, Transition } from '@headlessui/react'
 import { Fragment, useState } from 'react'
-import { Value } from '../lang/abstractSyntaxTreeTypes'
+import { Value } from '../lang/wasm'
 import {
  AvailableVars,
  addToInputHelper,
--- a/src/components/SetHorVertDistanceModal.tsx
+++ b/src/components/SetHorVertDistanceModal.tsx
@ -1,6 +1,6 @@
 import { Dialog, Transition } from '@headlessui/react'
 import { Fragment, useState } from 'react'
-import { Value } from '../lang/abstractSyntaxTreeTypes'
+import { Value } from '../lang/wasm'
 import {
  AvailableVars,
  addToInputHelper,
--- a/src/components/Stream.tsx
+++ b/src/components/Stream.tsx
@ -20,11 +20,15 @@ import {
  compareVec2Epsilon,
 } from 'lang/std/sketch'
 import { getNodeFromPath } from 'lang/queryAst'
-import { Program, VariableDeclarator } from 'lang/abstractSyntaxTreeTypes'
-import { modify_ast_for_sketch } from '../wasm-lib/pkg/wasm_lib'
+import {
+  Program,
+  VariableDeclarator,
+  rangeTypeFix,
+  modifyAstForSketch,
+} from 'lang/wasm'
 import { KCLError } from 'lang/errors'
 import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
-import { rangeTypeFix } from 'lang/abstractSyntaxTree'
+import { engineCommandManager } from '../lang/std/engineConnection'

 export const Stream = ({ className = '' }) => {
  const [isLoading, setIsLoading] = useState(true)
@ -32,7 +36,6 @@ export const Stream = ({ className = '' }) => {
  const videoRef = useRef<HTMLVideoElement>(null)
  const {
    mediaStream,
-    engineCommandManager,
    setButtonDownInStream,
    didDragInStream,
    setDidDragInStream,
@ -45,7 +48,6 @@ export const Stream = ({ className = '' }) => {
    programMemory,
  } = useStore((s) => ({
    mediaStream: s.mediaStream,
-    engineCommandManager: s.engineCommandManager,
    setButtonDownInStream: s.setButtonDownInStream,
    fileId: s.fileId,
    didDragInStream: s.didDragInStream,
@ -73,7 +75,7 @@ export const Stream = ({ className = '' }) => {
    if (!videoRef.current) return
    if (!mediaStream) return
    videoRef.current.srcObject = mediaStream
-  }, [mediaStream, engineCommandManager])
+  }, [mediaStream])

  const handleMouseDown: MouseEventHandler<HTMLVideoElement> = (e) => {
    if (!videoRef.current) return
@ -107,7 +109,7 @@ export const Stream = ({ className = '' }) => {
    }

    if (guiMode.mode === 'sketch' && guiMode.sketchMode === ('move' as any)) {
-      engineCommandManager?.sendSceneCommand({
+      engineCommandManager.sendSceneCommand({
        type: 'modeling_cmd_req',
        cmd: {
          type: 'handle_mouse_drag_start',
@ -121,7 +123,7 @@ export const Stream = ({ className = '' }) => {
        guiMode.sketchMode === ('sketch_line' as any)
      )
    ) {
-      engineCommandManager?.sendSceneCommand({
+      engineCommandManager.sendSceneCommand({
        type: 'modeling_cmd_req',
        cmd: {
          type: 'camera_drag_start',
@ -139,7 +141,7 @@ export const Stream = ({ className = '' }) => {
  const handleScroll: WheelEventHandler<HTMLVideoElement> = (e) => {
    if (!cameraMouseDragGuards[cameraControls].zoom.scrollCallback(e)) return

-    engineCommandManager?.sendSceneCommand({
+    engineCommandManager.sendSceneCommand({
      type: 'modeling_cmd_req',
      cmd: {
        type: 'default_camera_zoom',
@ -177,7 +179,7 @@ export const Stream = ({ className = '' }) => {
    }

    if (!didDragInStream) {
-      engineCommandManager?.sendSceneCommand({
+      engineCommandManager.sendSceneCommand({
        type: 'modeling_cmd_req',
        cmd: {
          type: 'select_with_point',
@ -214,7 +216,7 @@ export const Stream = ({ className = '' }) => {
        window: { x, y },
      }
    }
-    engineCommandManager?.sendSceneCommand(command).then(async (resp) => {
+    engineCommandManager.sendSceneCommand(command).then(async (resp) => {
      if (!(guiMode.mode === 'sketch')) return

      if (guiMode.sketchMode === 'selectFace') return
@ -240,9 +242,6 @@ export const Stream = ({ className = '' }) => {
      ) {
        // Let's get the updated ast.
        if (sketchGroupId === '') return
-
-        console.log('guiMode.pathId', guiMode.pathId)
-
        // We have a problem if we do not have an id for the sketch group.
        if (
          guiMode.pathId === undefined ||
@ -253,26 +252,14 @@ export const Stream = ({ className = '' }) => {

        let engineId = guiMode.pathId

-        try {
-          const updatedAst: Program = await modify_ast_for_sketch(
-            engineCommandManager,
-            JSON.stringify(ast),
-            variableName,
-            engineId
-          )
+        const updatedAst: Program = await modifyAstForSketch(
+          engineCommandManager,
+          ast,
+          variableName,
+          engineId
+        )

-          updateAst(updatedAst, false)
-        } catch (e: any) {
-          const parsed: RustKclError = JSON.parse(e.toString())
-          const kclError = new KCLError(
-            parsed.kind,
-            parsed.msg,
-            rangeTypeFix(parsed.sourceRanges)
-          )
-
-          console.log(kclError)
-          throw kclError
-        }
+        updateAst(updatedAst, false)
        return
      }

@ -285,7 +272,7 @@ export const Stream = ({ className = '' }) => {
        guiMode.waitingFirstClick &&
        !isEditingExistingSketch
      ) {
-        const curve = await engineCommandManager?.sendSceneCommand({
+        const curve = await engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: {
@ -326,7 +313,7 @@ export const Stream = ({ className = '' }) => {
        resp?.data?.data?.entities_modified?.length &&
        (!guiMode.waitingFirstClick || isEditingExistingSketch)
      ) {
-        const curve = await engineCommandManager?.sendSceneCommand({
+        const curve = await engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: {
@ -371,12 +358,12 @@ export const Stream = ({ className = '' }) => {
          setGuiMode({
            mode: 'default',
          })
-          engineCommandManager?.sendSceneCommand({
+          engineCommandManager.sendSceneCommand({
            type: 'modeling_cmd_req',
            cmd_id: uuidv4(),
            cmd: { type: 'edit_mode_exit' },
          })
-          engineCommandManager?.sendSceneCommand({
+          engineCommandManager.sendSceneCommand({
            type: 'modeling_cmd_req',
            cmd_id: uuidv4(),
            cmd: { type: 'default_camera_disable_sketch_mode' },
--- a/src/components/TextEditor.tsx
+++ b/src/components/TextEditor.tsx
@ -30,6 +30,7 @@ import { isOverlap, roundOff } from 'lib/utils'
 import { kclErrToDiagnostic } from 'lang/errors'
 import { CSSRuleObject } from 'tailwindcss/types/config'
 import interact from '@replit/codemirror-interact'
+import { engineCommandManager } from '../lang/std/engineConnection'

 export const editorShortcutMeta = {
  formatCode: {
@ -52,7 +53,6 @@ export const TextEditor = ({
    code,
    deferredSetCode,
    editorView,
-    engineCommandManager,
    formatCode,
    isLSPServerReady,
    selectionRanges,
@ -64,7 +64,6 @@ export const TextEditor = ({
    code: s.code,
    deferredSetCode: s.deferredSetCode,
    editorView: s.editorView,
-    engineCommandManager: s.engineCommandManager,
    formatCode: s.formatCode,
    isLSPServerReady: s.isLSPServerReady,
    selectionRanges: s.selectionRanges,
@ -173,7 +172,7 @@ export const TextEditor = ({
    const idBasedSelections = codeBasedSelections
      .map(({ type, range }) => {
        const hasOverlap = Object.entries(
-          engineCommandManager?.sourceRangeMap || {}
+          engineCommandManager.sourceRangeMap || {}
        ).filter(([_, sourceRange]) => {
          return isOverlap(sourceRange, range)
        })
@ -186,7 +185,7 @@ export const TextEditor = ({
      })
      .filter(Boolean) as any

-    engineCommandManager?.cusorsSelected({
+    engineCommandManager.cusorsSelected({
      otherSelections: [],
      idBasedSelections,
    })
--- a/src/components/Toolbar/EqualAngle.tsx
+++ b/src/components/Toolbar/EqualAngle.tsx
@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { toolTips, useStore } from '../../useStore'
-import { Value, VariableDeclarator } from '../../lang/abstractSyntaxTreeTypes'
+import { Value, VariableDeclarator } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/EqualLength.tsx
+++ b/src/components/Toolbar/EqualLength.tsx
@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { toolTips, useStore } from '../../useStore'
-import { Value, VariableDeclarator } from '../../lang/abstractSyntaxTreeTypes'
+import { Value, VariableDeclarator } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/HorzVert.tsx
+++ b/src/components/Toolbar/HorzVert.tsx
@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { toolTips, useStore } from '../../useStore'
-import { Value } from '../../lang/abstractSyntaxTreeTypes'
+import { Value } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/Intersect.tsx
+++ b/src/components/Toolbar/Intersect.tsx
@ -1,11 +1,7 @@
 import { useState, useEffect } from 'react'
 import { create } from 'react-modal-promise'
 import { toolTips, useStore } from '../../useStore'
-import {
-  BinaryPart,
-  Value,
-  VariableDeclarator,
-} from '../../lang/abstractSyntaxTreeTypes'
+import { BinaryPart, Value, VariableDeclarator } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/RemoveConstrainingValues.tsx
+++ b/src/components/Toolbar/RemoveConstrainingValues.tsx
@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { toolTips, useStore } from '../../useStore'
-import { Value } from '../../lang/abstractSyntaxTreeTypes'
+import { Value } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/SetAbsDistance.tsx
+++ b/src/components/Toolbar/SetAbsDistance.tsx
@ -1,7 +1,7 @@
 import { useState, useEffect } from 'react'
 import { create } from 'react-modal-promise'
 import { toolTips, useStore } from '../../useStore'
-import { Value } from '../../lang/abstractSyntaxTreeTypes'
+import { Value } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
@ -133,7 +133,7 @@ export const SetAbsDistance = ({ buttonType }: { buttonType: ButtonType }) => {
            callBack: updateCursors(setCursor, selectionRanges, pathToNodeMap),
          })
        } catch (e) {
-          console.log('e', e)
+          console.log('error', e)
        }
      }}
      disabled={!enableAngLen}
--- a/src/components/Toolbar/SetAngleBetween.tsx
+++ b/src/components/Toolbar/SetAngleBetween.tsx
@ -1,11 +1,7 @@
 import { useState, useEffect } from 'react'
 import { create } from 'react-modal-promise'
 import { toolTips, useStore } from '../../useStore'
-import {
-  BinaryPart,
-  Value,
-  VariableDeclarator,
-} from '../../lang/abstractSyntaxTreeTypes'
+import { BinaryPart, Value, VariableDeclarator } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
--- a/src/components/Toolbar/SetHorzVertDistance.tsx
+++ b/src/components/Toolbar/SetHorzVertDistance.tsx
@ -1,11 +1,7 @@
 import { useState, useEffect } from 'react'
 import { create } from 'react-modal-promise'
 import { toolTips, useStore } from '../../useStore'
-import {
-  BinaryPart,
-  Value,
-  VariableDeclarator,
-} from '../../lang/abstractSyntaxTreeTypes'
+import { BinaryPart, Value, VariableDeclarator } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
@ -21,8 +17,6 @@ import { GetInfoModal } from '../SetHorVertDistanceModal'
 import { createLiteral, createVariableDeclaration } from '../../lang/modifyAst'
 import { removeDoubleNegatives } from '../AvailableVarsHelpers'
 import { updateCursors } from '../../lang/util'
-import { ActionIcon } from 'components/ActionIcon'
-import { sketchButtonClassnames } from 'Toolbar'

 const getModalInfo = create(GetInfoModal as any)

--- a/src/components/Toolbar/setAngleLength.tsx
+++ b/src/components/Toolbar/setAngleLength.tsx
@ -1,7 +1,7 @@
 import { useState, useEffect } from 'react'
 import { create } from 'react-modal-promise'
 import { toolTips, useStore } from '../../useStore'
-import { Value } from '../../lang/abstractSyntaxTreeTypes'
+import { Value } from '../../lang/wasm'
 import {
  getNodePathFromSourceRange,
  getNodeFromPath,
@ -147,7 +147,7 @@ export const SetAngleLength = ({
            callBack: updateCursors(setCursor, selectionRanges, pathToNodeMap),
          })
        } catch (e) {
-          console.log('e', e)
+          console.log('erorr', e)
        }
      }}
      disabled={!enableAngLen}
--- a/src/components/UserSidebarMenu.tsx
+++ b/src/components/UserSidebarMenu.tsx
@ -137,7 +137,7 @@ const UserSidebarMenu = ({ user }: { user?: User }) => {
                  Settings
                </ActionButton>
                <ActionButton
-                  Element="link"
+                  Element="externalLink"
                  to="https://github.com/KittyCAD/modeling-app/discussions"
                  icon={{ icon: faGithub }}
                  className="border-transparent dark:border-transparent dark:hover:border-liquid-60"
--- a/src/editor/lsp/client.ts
+++ b/src/editor/lsp/client.ts
@ -109,7 +109,6 @@ export default class Client extends jsrpc.JSONRPCServerAndClient {
        }
      }
      messageString += message
-      // console.log(messageString)
      return
    })

--- a/src/editor/lsp/plugin.ts
+++ b/src/editor/lsp/plugin.ts
@ -13,6 +13,7 @@ import {
  CompletionItemKind,
  CompletionTriggerKind,
 } from 'vscode-languageserver-protocol'
+import debounce from 'debounce-promise'

 import type {
  Completion,
@ -53,14 +54,11 @@ export class LanguageServerPlugin implements PluginValue {
  private languageId: string
  private documentVersion: number

-  private changesTimeout: number
-
  constructor(private view: EditorView, private allowHTMLContent: boolean) {
    this.client = this.view.state.facet(client)
    this.documentUri = this.view.state.facet(documentUri)
    this.languageId = this.view.state.facet(languageId)
    this.documentVersion = 0
-    this.changesTimeout = 0

    this.client.attachPlugin(this)

@ -71,12 +69,10 @@ export class LanguageServerPlugin implements PluginValue {

  update({ docChanged }: ViewUpdate) {
    if (!docChanged) return
-    if (this.changesTimeout) clearTimeout(this.changesTimeout)
-    this.changesTimeout = window.setTimeout(() => {
-      this.sendChange({
-        documentText: this.view.state.doc.toString(),
-      })
-    }, changesDelay)
+
+    this.sendChange({
+      documentText: this.view.state.doc.toString(),
+    })
  }

  destroy() {
@ -99,14 +95,32 @@ export class LanguageServerPlugin implements PluginValue {

  async sendChange({ documentText }: { documentText: string }) {
    if (!this.client.ready) return
+
+    if (documentText.length > 5000) {
+      // Clear out the text it thinks we have, large documents will throw a stack error.
+      // This is obviously not a good fix but it works for now til we figure
+      // out the stack limits in wasm and also rewrite the parser.
+      // Since this is only for hover and completions it will be fine,
+      // completions will still work for stdlib but hover will not.
+      // That seems like a fine trade-off for a working editor for the time
+      // being.
+      documentText = ''
+    }
+
    try {
-      await this.client.textDocumentDidChange({
-        textDocument: {
-          uri: this.documentUri,
-          version: this.documentVersion++,
+      debounce(
+        () => {
+          return this.client.textDocumentDidChange({
+            textDocument: {
+              uri: this.documentUri,
+              version: this.documentVersion++,
+            },
+            contentChanges: [{ text: documentText }],
+          })
        },
-        contentChanges: [{ text: documentText }],
-      })
+        changesDelay,
+        { leading: true }
+      )
    } catch (e) {
      console.error(e)
    }
--- a/src/hooks/useAppMode.ts
+++ b/src/hooks/useAppMode.ts
@ -8,6 +8,7 @@ import { ArtifactMap, EngineCommandManager } from 'lang/std/engineConnection'
 import { Models } from '@kittycad/lib/dist/types/src'
 import { isReducedMotion } from 'lang/util'
 import { isOverlap } from 'lib/utils'
+import { engineCommandManager } from '../lang/std/engineConnection'

 interface DefaultPlanes {
  xy: string
@ -17,19 +18,13 @@ interface DefaultPlanes {
 }

 export function useAppMode() {
-  const {
-    guiMode,
-    setGuiMode,
-    selectionRanges,
-    engineCommandManager,
-    selectionRangeTypeMap,
-  } = useStore((s) => ({
-    guiMode: s.guiMode,
-    setGuiMode: s.setGuiMode,
-    selectionRanges: s.selectionRanges,
-    engineCommandManager: s.engineCommandManager,
-    selectionRangeTypeMap: s.selectionRangeTypeMap,
-  }))
+  const { guiMode, setGuiMode, selectionRanges, selectionRangeTypeMap } =
+    useStore((s) => ({
+      guiMode: s.guiMode,
+      setGuiMode: s.setGuiMode,
+      selectionRanges: s.selectionRanges,
+      selectionRangeTypeMap: s.selectionRangeTypeMap,
+    }))
  const [defaultPlanes, setDefaultPlanes] = useState<DefaultPlanes | null>(null)
  useEffect(() => {
    if (
@ -65,7 +60,7 @@ export function useAppMode() {
        setDefaultPlanesHidden(engineCommandManager, localDefaultPlanes, true)
        // TODO figure out the plane to use based on the sketch
        // maybe it's easier to make a new plane than rely on the defaults
-        await engineCommandManager?.sendSceneCommand({
+        await engineCommandManager.sendSceneCommand({
          type: 'modeling_cmd_req',
          cmd_id: uuidv4(),
          cmd: {
@ -135,7 +130,7 @@ export function useAppMode() {
  ])

  useEffect(() => {
-    const unSub = engineCommandManager?.subscribeTo({
+    const unSub = engineCommandManager.subscribeTo({
      event: 'select_with_point',
      callback: async ({ data }) => {
        if (!data.entity_id) return
@ -144,18 +139,16 @@ export function useAppMode() {
          // user clicked something else in the scene
          return
        }
-        const sketchModeResponse = await engineCommandManager?.sendSceneCommand(
-          {
-            type: 'modeling_cmd_req',
-            cmd_id: uuidv4(),
-            cmd: {
-              type: 'sketch_mode_enable',
-              plane_id: data.entity_id,
-              ortho: true,
-              animated: !isReducedMotion(),
-            },
-          }
-        )
+        const sketchModeResponse = await engineCommandManager.sendSceneCommand({
+          type: 'modeling_cmd_req',
+          cmd_id: uuidv4(),
+          cmd: {
+            type: 'sketch_mode_enable',
+            plane_id: data.entity_id,
+            ortho: true,
+            animated: !isReducedMotion(),
+          },
+        })
        setDefaultPlanesHidden(engineCommandManager, defaultPlanes, true)
        const sketchUuid = uuidv4()
        const proms: any[] = []
@ -178,8 +171,7 @@ export function useAppMode() {
            },
          })
        )
-        const res = await Promise.all(proms)
-        console.log('res', res)
+        await Promise.all(proms)
        setGuiMode({
          mode: 'sketch',
          sketchMode: 'sketchEdit',
@ -209,7 +201,7 @@ async function createPlane(
  }
 ) {
  const planeId = uuidv4()
-  await engineCommandManager?.sendSceneCommand({
+  await engineCommandManager.sendSceneCommand({
    type: 'modeling_cmd_req',
    cmd: {
      type: 'make_plane',
@ -221,7 +213,7 @@ async function createPlane(
    },
    cmd_id: planeId,
  })
-  await engineCommandManager?.sendSceneCommand({
+  await engineCommandManager.sendSceneCommand({
    type: 'modeling_cmd_req',
    cmd: {
      type: 'plane_set_color',
@ -234,12 +226,12 @@ async function createPlane(
 }

 function setDefaultPlanesHidden(
-  engineCommandManager: EngineCommandManager | undefined,
+  engineCommandManager: EngineCommandManager,
  defaultPlanes: DefaultPlanes,
  hidden: boolean
 ) {
  Object.values(defaultPlanes).forEach((planeId) => {
-    engineCommandManager?.sendSceneCommand({
+    engineCommandManager.sendSceneCommand({
      type: 'modeling_cmd_req',
      cmd_id: uuidv4(),
      cmd: {
--- a/src/hooks/useEngineConnectionSubscriptions.ts
+++ b/src/hooks/useEngineConnectionSubscriptions.ts
@ -1,14 +1,9 @@
 import { useEffect } from 'react'
 import { useStore } from 'useStore'
+import { engineCommandManager } from '../lang/std/engineConnection'

 export function useEngineConnectionSubscriptions() {
-  const {
-    engineCommandManager,
-    setCursor2,
-    setHighlightRange,
-    highlightRange,
-  } = useStore((s) => ({
-    engineCommandManager: s.engineCommandManager,
+  const { setCursor2, setHighlightRange, highlightRange } = useStore((s) => ({
    setCursor2: s.setCursor2,
    setHighlightRange: s.setHighlightRange,
    highlightRange: s.highlightRange,
--- a/src/hooks/useSetupEngineManager.ts
+++ b/src/hooks/useSetupEngineManager.ts
@ -1,53 +1,89 @@
-import { useLayoutEffect } from 'react'
-import { _executor } from '../lang/executor'
+import { useLayoutEffect, useEffect, useRef } from 'react'
+import { _executor } from '../lang/wasm'
 import { useStore } from '../useStore'
-import { EngineCommandManager } from '../lang/std/engineConnection'
+import { engineCommandManager } from '../lang/std/engineConnection'
+import { deferExecution } from 'lib/utils'
+import { v4 as uuidv4 } from 'uuid'

 export function useSetupEngineManager(
  streamRef: React.RefObject<HTMLDivElement>,
  token?: string
 ) {
  const {
-    setEngineCommandManager,
    setMediaStream,
    setIsStreamReady,
    setStreamDimensions,
+    streamDimensions,
    executeCode,
  } = useStore((s) => ({
-    setEngineCommandManager: s.setEngineCommandManager,
    setMediaStream: s.setMediaStream,
    setIsStreamReady: s.setIsStreamReady,
    setStreamDimensions: s.setStreamDimensions,
+    streamDimensions: s.streamDimensions,
    executeCode: s.executeCode,
  }))

  const streamWidth = streamRef?.current?.offsetWidth
  const streamHeight = streamRef?.current?.offsetHeight

+  const hasSetNonZeroDimensions = useRef<boolean>(false)
+
+  useLayoutEffect(() => {
+    // Load the engine command manager once with the initial width and height,
+    // then we do not want to reload it.
+    const { width: quadWidth, height: quadHeight } = getDimensions(
+      streamWidth,
+      streamHeight
+    )
+    if (!hasSetNonZeroDimensions.current && quadHeight && quadWidth) {
+      engineCommandManager.start({
+        setMediaStream,
+        setIsStreamReady,
+        width: quadWidth,
+        height: quadHeight,
+        executeCode,
+        token,
+      })
+      setStreamDimensions({
+        streamWidth: quadWidth,
+        streamHeight: quadHeight,
+      })
+      hasSetNonZeroDimensions.current = true
+    }
+  }, [streamRef?.current?.offsetWidth, streamRef?.current?.offsetHeight])
+
+  useEffect(() => {
+    const handleResize = deferExecution(() => {
+      const { width, height } = getDimensions(
+        streamRef?.current?.offsetWidth,
+        streamRef?.current?.offsetHeight
+      )
+      if (
+        streamDimensions.streamWidth !== width ||
+        streamDimensions.streamHeight !== height
+      ) {
+        engineCommandManager.handleResize({
+          streamWidth: width,
+          streamHeight: height,
+        })
+        setStreamDimensions({
+          streamWidth: width,
+          streamHeight: height,
+        })
+      }
+    }, 500)
+
+    window.addEventListener('resize', handleResize)
+    return () => {
+      window.removeEventListener('resize', handleResize)
+    }
+  }, [])
+}
+
+function getDimensions(streamWidth?: number, streamHeight?: number) {
  const width = streamWidth ? streamWidth : 0
  const quadWidth = Math.round(width / 4) * 4
  const height = streamHeight ? streamHeight : 0
  const quadHeight = Math.round(height / 4) * 4
-
-  useLayoutEffect(() => {
-    setStreamDimensions({
-      streamWidth: quadWidth,
-      streamHeight: quadHeight,
-    })
-    if (!width || !height) return
-    const eng = new EngineCommandManager({
-      setMediaStream,
-      setIsStreamReady,
-      width: quadWidth,
-      height: quadHeight,
-      token,
-    })
-    setEngineCommandManager(eng)
-    eng.waitForReady.then(() => {
-      executeCode()
-    })
-    return () => {
-      eng?.tearDown()
-    }
-  }, [quadWidth, quadHeight])
+  return { width: quadWidth, height: quadHeight }
 }
--- a/src/hooks/useToolbarGuards.ts
+++ b/src/hooks/useToolbarGuards.ts
@ -48,7 +48,7 @@ export function useConvertToVariable() {

      updateAst(_modifiedAst, true)
    } catch (e) {
-      console.log('e', e)
+      console.log('error', e)
    }
  }

--- a/src/lang/abstractSyntaxTree.test.ts
+++ b/src/lang/abstractSyntaxTree.test.ts
@ -1,12 +1,11 @@
-import { parser_wasm } from './abstractSyntaxTree'
 import { KCLError } from './errors'
-import { initPromise } from './rust'
+import { initPromise, parse } from './wasm'

 beforeAll(() => initPromise)

 describe('testing AST', () => {
  test('5 + 6', () => {
-    const result = parser_wasm('5 +6')
+    const result = parse('5 +6')
    delete (result as any).nonCodeMeta
    expect(result.body).toEqual([
      {
@ -37,7 +36,7 @@ describe('testing AST', () => {
    ])
  })
  test('const myVar = 5', () => {
-    const { body } = parser_wasm('const myVar = 5')
+    const { body } = parse('const myVar = 5')
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -71,7 +70,7 @@ describe('testing AST', () => {
    const code = `const myVar = 5
 const newVar = myVar + 1
 `
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -143,7 +142,7 @@ const newVar = myVar + 1

 describe('testing function declaration', () => {
  test('fn funcN = () => {}', () => {
-    const { body } = parser_wasm('fn funcN = () => {}')
+    const { body } = parse('fn funcN = () => {}')
    delete (body[0] as any).declarations[0].init.body.nonCodeMeta
    expect(body).toEqual([
      {
@ -179,7 +178,7 @@ describe('testing function declaration', () => {
    ])
  })
  test('fn funcN = (a, b) => {return a + b}', () => {
-    const { body } = parser_wasm(
+    const { body } = parse(
      ['fn funcN = (a, b) => {', '  return a + b', '}'].join('\n')
    )
    delete (body[0] as any).declarations[0].init.body.nonCodeMeta
@ -256,7 +255,7 @@ describe('testing function declaration', () => {
  test('call expression assignment', () => {
    const code = `fn funcN = (a, b) => { return a + b }
 const myVar = funcN(1, 2)`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    delete (body[0] as any).declarations[0].init.body.nonCodeMeta
    expect(body).toEqual([
      {
@ -388,7 +387,7 @@ describe('testing pipe operator special', () => {
  |> lineTo([1, 1], %)
  |> rx(45, %)
 `
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    delete (body[0] as any).declarations[0].init.nonCodeMeta
    expect(body).toEqual([
      {
@ -404,7 +403,7 @@ describe('testing pipe operator special', () => {
            id: { type: 'Identifier', start: 6, end: 14, name: 'mySketch' },
            init: {
              type: 'PipeExpression',
-              start: 15,
+              start: 17,
              end: 145,
              body: [
                {
@ -624,7 +623,7 @@ describe('testing pipe operator special', () => {
  })
  test('pipe operator with binary expression', () => {
    let code = `const myVar = 5 + 6 |> myFunc(45, %)`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    delete (body as any)[0].declarations[0].init.nonCodeMeta
    expect(body).toEqual([
      {
@ -645,7 +644,7 @@ describe('testing pipe operator special', () => {
            },
            init: {
              type: 'PipeExpression',
-              start: 12,
+              start: 14,
              end: 36,
              body: [
                {
@ -706,7 +705,7 @@ describe('testing pipe operator special', () => {
  })
  test('array expression', () => {
    let code = `const yo = [1, '2', three, 4 + 5]`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -781,7 +780,7 @@ describe('testing pipe operator special', () => {
      'const three = 3',
      "const yo = {aStr: 'str', anum: 2, identifier: three, binExp: 4 + 5}",
    ].join('\n')
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -925,7 +924,7 @@ describe('testing pipe operator special', () => {
    const code = `const yo = {key: {
  key2: 'value'
 }}`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -993,7 +992,7 @@ describe('testing pipe operator special', () => {
  })
  test('object expression with array ast', () => {
    const code = `const yo = {key: [1, '2']}`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -1057,7 +1056,7 @@ describe('testing pipe operator special', () => {
  })
  test('object memberExpression simple', () => {
    const code = `const prop = yo.one.two`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -1112,7 +1111,7 @@ describe('testing pipe operator special', () => {
  })
  test('object memberExpression with square braces', () => {
    const code = `const prop = yo.one["two"]`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -1168,7 +1167,7 @@ describe('testing pipe operator special', () => {
  })
  test('object memberExpression with two square braces literal and identifier', () => {
    const code = `const prop = yo["one"][two]`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body).toEqual([
      {
        type: 'VariableDeclaration',
@ -1227,7 +1226,7 @@ describe('testing pipe operator special', () => {
 describe('nests binary expressions correctly', () => {
  it('works with the simple case', () => {
    const code = `const yo = 1 + 2`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body[0]).toEqual({
      type: 'VariableDeclaration',
      start: 0,
@ -1271,7 +1270,7 @@ describe('nests binary expressions correctly', () => {
  it('should nest according to precedence with multiply first', () => {
    // should be binExp { binExp { lit-1 * lit-2 } + lit}
    const code = `const yo = 1 * 2 + 3`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body[0]).toEqual({
      type: 'VariableDeclaration',
      start: 0,
@ -1328,7 +1327,7 @@ describe('nests binary expressions correctly', () => {
  it('should nest according to precedence with sum first', () => {
    // should be binExp { lit-1 + binExp { lit-2 * lit-3 } }
    const code = `const yo = 1 + 2 * 3`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect(body[0]).toEqual({
      type: 'VariableDeclaration',
      start: 0,
@ -1384,7 +1383,7 @@ describe('nests binary expressions correctly', () => {
  })
  it('should nest properly with two opperators of equal precedence', () => {
    const code = `const yo = 1 + 2 - 3`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect((body[0] as any).declarations[0].init).toEqual({
      type: 'BinaryExpression',
      start: 11,
@ -1421,7 +1420,7 @@ describe('nests binary expressions correctly', () => {
  })
  it('should nest properly with two opperators of equal (but higher) precedence', () => {
    const code = `const yo = 1 * 2 / 3`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    expect((body[0] as any).declarations[0].init).toEqual({
      type: 'BinaryExpression',
      start: 11,
@ -1458,7 +1457,7 @@ describe('nests binary expressions correctly', () => {
  })
  it('should nest properly with longer example', () => {
    const code = `const yo = 1 + 2 * (3 - 4) / 5 + 6`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const init = (body[0] as any).declarations[0].init
    expect(init).toEqual({
      type: 'BinaryExpression',
@ -1520,14 +1519,12 @@ const key = 'c'`
        value: 'this is a comment',
      },
    }
-    const { nonCodeMeta } = parser_wasm(code)
+    const { nonCodeMeta } = parse(code)
    expect(nonCodeMeta.nonCodeNodes[0]).toEqual(nonCodeMetaInstance)

    // extra whitespace won't change it's position (0) or value (NB the start end would have changed though)
    const codeWithExtraStartWhitespace = '\n\n\n' + code
-    const { nonCodeMeta: nonCodeMeta2 } = parser_wasm(
-      codeWithExtraStartWhitespace
-    )
+    const { nonCodeMeta: nonCodeMeta2 } = parse(codeWithExtraStartWhitespace)
    expect(nonCodeMeta2.nonCodeNodes[0].value).toStrictEqual(
      nonCodeMetaInstance.value
    )
@ -1545,7 +1542,7 @@ const key = 'c'`
  |> close(%)
 `

-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const indexOfSecondLineToExpression = 2
    const sketchNonCodeMeta = (body as any)[0].declarations[0].init.nonCodeMeta
      .nonCodeNodes
@ -1569,7 +1566,7 @@ const key = 'c'`
      '  |> rx(90, %)',
    ].join('\n')

-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const sketchNonCodeMeta = (body[0] as any).declarations[0].init.nonCodeMeta
      .nonCodeNodes
    expect(sketchNonCodeMeta[3]).toEqual({
@ -1587,7 +1584,7 @@ const key = 'c'`
 describe('test UnaryExpression', () => {
  it('should parse a unary expression in simple var dec situation', () => {
    const code = `const myVar = -min(4, 100)`
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const myVarInit = (body?.[0] as any).declarations[0]?.init
    expect(myVarInit).toEqual({
      type: 'UnaryExpression',
@ -1613,7 +1610,7 @@ describe('test UnaryExpression', () => {
 describe('testing nested call expressions', () => {
  it('callExp in a binExp in a callExp', () => {
    const code = 'const myVar = min(100, 1 + legLen(5, 3))'
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const myVarInit = (body?.[0] as any).declarations[0]?.init
    expect(myVarInit).toEqual({
      type: 'CallExpression',
@ -1651,7 +1648,7 @@ describe('testing nested call expressions', () => {
 describe('should recognise callExpresions in binaryExpressions', () => {
  const code = "xLineTo(segEndX('seg02', %) + 1, %)"
  it('should recognise the callExp', () => {
-    const { body } = parser_wasm(code)
+    const { body } = parse(code)
    const callExpArgs = (body?.[0] as any).expression?.arguments
    expect(callExpArgs).toEqual([
      {
@ -1690,8 +1687,7 @@ describe('parsing errors', () => {

    let _theError
    try {
-      const result = expect(parser_wasm(code))
-      console.log('result', result)
+      const result = expect(parse(code))
    } catch (e) {
      _theError = e
    }
--- a/src/lang/abstractSyntaxTree.ts
+++ b/src/lang/abstractSyntaxTree.ts
@ -1,48 +0,0 @@
-import { Program } from './abstractSyntaxTreeTypes'
-import { parse_js } from '../wasm-lib/pkg/wasm_lib'
-import { initPromise } from './rust'
-import { Token } from './tokeniser'
-import { KCLError } from './errors'
-import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
-
-export const rangeTypeFix = (ranges: number[][]): [number, number][] =>
-  ranges.map(([start, end]) => [start, end])
-
-export const parser_wasm = (code: string): Program => {
-  try {
-    const program: Program = parse_js(code)
-    return program
-  } catch (e: any) {
-    const parsed: RustKclError = JSON.parse(e.toString())
-    const kclError = new KCLError(
-      parsed.kind,
-      parsed.msg,
-      rangeTypeFix(parsed.sourceRanges)
-    )
-
-    console.log(kclError)
-    throw kclError
-  }
-}
-
-export async function asyncParser(code: string): Promise<Program> {
-  await initPromise
-  try {
-    const program: Program = parse_js(code)
-    return program
-  } catch (e: any) {
-    const parsed: RustKclError = JSON.parse(e.toString())
-    const kclError = new KCLError(
-      parsed.kind,
-      parsed.msg,
-      rangeTypeFix(parsed.sourceRanges)
-    )
-
-    console.log(kclError)
-    throw kclError
-  }
-}
-
-export function rangeOfToken(token: Token | undefined): [number, number][] {
-  return token === undefined ? [] : [[token.start, token.end]]
-}
--- a/src/lang/abstractSyntaxTreeTypes.ts
+++ b/src/lang/abstractSyntaxTreeTypes.ts
@ -1,37 +0,0 @@
-export type { Program } from '../wasm-lib/kcl/bindings/Program'
-export type { Value } from '../wasm-lib/kcl/bindings/Value'
-export type { ObjectExpression } from '../wasm-lib/kcl/bindings/ObjectExpression'
-export type { MemberExpression } from '../wasm-lib/kcl/bindings/MemberExpression'
-export type { PipeExpression } from '../wasm-lib/kcl/bindings/PipeExpression'
-export type { VariableDeclaration } from '../wasm-lib/kcl/bindings/VariableDeclaration'
-export type { PipeSubstitution } from '../wasm-lib/kcl/bindings/PipeSubstitution'
-export type { Identifier } from '../wasm-lib/kcl/bindings/Identifier'
-export type { UnaryExpression } from '../wasm-lib/kcl/bindings/UnaryExpression'
-export type { BinaryExpression } from '../wasm-lib/kcl/bindings/BinaryExpression'
-export type { ReturnStatement } from '../wasm-lib/kcl/bindings/ReturnStatement'
-export type { ExpressionStatement } from '../wasm-lib/kcl/bindings/ExpressionStatement'
-export type { CallExpression } from '../wasm-lib/kcl/bindings/CallExpression'
-export type { VariableDeclarator } from '../wasm-lib/kcl/bindings/VariableDeclarator'
-export type { BinaryPart } from '../wasm-lib/kcl/bindings/BinaryPart'
-export type { Literal } from '../wasm-lib/kcl/bindings/Literal'
-export type { ArrayExpression } from '../wasm-lib/kcl/bindings/ArrayExpression'
-
-export type SyntaxType =
-  | 'Program'
-  | 'ExpressionStatement'
-  | 'BinaryExpression'
-  | 'CallExpression'
-  | 'Identifier'
-  | 'ReturnStatement'
-  | 'VariableDeclaration'
-  | 'VariableDeclarator'
-  | 'MemberExpression'
-  | 'ArrayExpression'
-  | 'ObjectExpression'
-  | 'ObjectProperty'
-  | 'FunctionExpression'
-  | 'PipeExpression'
-  | 'PipeSubstitution'
-  | 'Literal'
-  | 'NonCodeNode'
-  | 'UnaryExpression'
--- a/src/lang/artifact.test.ts
+++ b/src/lang/artifact.test.ts
@ -1,5 +1,4 @@
-import { parser_wasm } from './abstractSyntaxTree'
-import { initPromise } from './rust'
+import { parse, initPromise } from './wasm'
 import { enginelessExecutor } from '../lib/testHelpers'

 beforeAll(() => initPromise)
@ -13,7 +12,7 @@ const mySketch001 = startSketchAt([0, 0])
  |> lineTo([0.46, -5.82], %)
  // |> rx(45, %)
 show(mySketch001)`
-    const programMemory = await enginelessExecutor(parser_wasm(code))
+    const programMemory = await enginelessExecutor(parse(code))
    // @ts-ignore
    const shown = programMemory?.return?.map(
      // @ts-ignore
@ -69,7 +68,7 @@ const mySketch001 = startSketchAt([0, 0])
  // |> rx(45, %)
  |> extrude(2, %)
 show(mySketch001)`
-    const programMemory = await enginelessExecutor(parser_wasm(code))
+    const programMemory = await enginelessExecutor(parse(code))
    // @ts-ignore
    const shown = programMemory?.return?.map(
      // @ts-ignore
@ -109,7 +108,7 @@ const sk2 = startSketchAt([0, 0])


 show(theExtrude, sk2)`
-    const programMemory = await enginelessExecutor(parser_wasm(code))
+    const programMemory = await enginelessExecutor(parse(code))
    // @ts-ignore
    const geos = programMemory?.return?.map(
      // @ts-ignore
--- a/src/lang/executor.test.ts
+++ b/src/lang/executor.test.ts
@ -1,10 +1,7 @@
 import fs from 'node:fs'

-import { parser_wasm } from './abstractSyntaxTree'
-import { ProgramMemory, SketchGroup } from './executor'
-import { initPromise } from './rust'
+import { parse, ProgramMemory, SketchGroup, initPromise } from './wasm'
 import { enginelessExecutor } from '../lib/testHelpers'
-import { vi } from 'vitest'
 import { KCLError } from './errors'

 beforeAll(() => initPromise)
@ -403,7 +400,7 @@ async function exe(
  code: string,
  programMemory: ProgramMemory = { root: {}, return: null }
 ) {
-  const ast = parser_wasm(code)
+  const ast = parse(code)

  const result = await enginelessExecutor(ast, programMemory)
  return result
--- a/src/lang/executor.ts
+++ b/src/lang/executor.ts
@ -1,81 +0,0 @@
-import { Program } from './abstractSyntaxTreeTypes'
-import {
-  EngineCommandManager,
-  ArtifactMap,
-  SourceRangeMap,
-} from './std/engineConnection'
-import { ProgramReturn } from '../wasm-lib/kcl/bindings/ProgramReturn'
-import { MemoryItem } from '../wasm-lib/kcl/bindings/MemoryItem'
-import { execute_wasm } from '../wasm-lib/pkg/wasm_lib'
-import { KCLError } from './errors'
-import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
-import { rangeTypeFix } from './abstractSyntaxTree'
-
-export type { SourceRange } from '../wasm-lib/kcl/bindings/SourceRange'
-export type { Position } from '../wasm-lib/kcl/bindings/Position'
-export type { Rotation } from '../wasm-lib/kcl/bindings/Rotation'
-export type { Path } from '../wasm-lib/kcl/bindings/Path'
-export type { SketchGroup } from '../wasm-lib/kcl/bindings/SketchGroup'
-export type { MemoryItem } from '../wasm-lib/kcl/bindings/MemoryItem'
-export type { ExtrudeSurface } from '../wasm-lib/kcl/bindings/ExtrudeSurface'
-
-export type PathToNode = [string | number, string][]
-
-interface Memory {
-  [key: string]: MemoryItem
-}
-
-export interface ProgramMemory {
-  root: Memory
-  return: ProgramReturn | null
-}
-
-export const executor = async (
-  node: Program,
-  programMemory: ProgramMemory = { root: {}, return: null },
-  engineCommandManager: EngineCommandManager,
-  // work around while the gemotry is still be stored on the frontend
-  // will be removed when the stream UI is added.
-  tempMapCallback: (a: {
-    artifactMap: ArtifactMap
-    sourceRangeMap: SourceRangeMap
-  }) => void = () => {}
-): Promise<ProgramMemory> => {
-  engineCommandManager.startNewSession()
-  const _programMemory = await _executor(
-    node,
-    programMemory,
-    engineCommandManager
-  )
-  const { artifactMap, sourceRangeMap } =
-    await engineCommandManager.waitForAllCommands(node, _programMemory)
-  tempMapCallback({ artifactMap, sourceRangeMap })
-
-  engineCommandManager.endSession()
-  return _programMemory
-}
-
-export const _executor = async (
-  node: Program,
-  programMemory: ProgramMemory = { root: {}, return: null },
-  engineCommandManager: EngineCommandManager
-): Promise<ProgramMemory> => {
-  try {
-    const memory: ProgramMemory = await execute_wasm(
-      JSON.stringify(node),
-      JSON.stringify(programMemory),
-      engineCommandManager
-    )
-    return memory
-  } catch (e: any) {
-    const parsed: RustKclError = JSON.parse(e.toString())
-    const kclError = new KCLError(
-      parsed.kind,
-      parsed.msg,
-      rangeTypeFix(parsed.sourceRanges)
-    )
-
-    console.log(kclError)
-    throw kclError
-  }
-}
--- a/src/lang/getNodePathFromSourceRange.test.ts
+++ b/src/lang/getNodePathFromSourceRange.test.ts
@ -1,6 +1,5 @@
 import { getNodePathFromSourceRange, getNodeFromPath } from './queryAst'
-import { parser_wasm } from './abstractSyntaxTree'
-import { initPromise } from './rust'
+import { Identifier, parse, initPromise } from './wasm'

 beforeAll(() => initPromise)

@ -20,11 +19,88 @@ const sk3 = startSketchAt([0, 0])
      lineToSubstringIndex + subStr.length,
    ]

-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const nodePath = getNodePathFromSourceRange(ast, sourceRange)
    const { node } = getNodeFromPath<any>(ast, nodePath)

    expect([node.start, node.end]).toEqual(sourceRange)
    expect(node.type).toBe('CallExpression')
  })
+  it('gets path right for function definition params', () => {
+    const code = `fn cube = (pos, scale) => {
+  const sg = startSketchAt(pos)
+    |> line([0, scale], %)
+    |> line([scale, 0], %)
+    |> line([0, -scale], %)
+
+  return sg
+}
+
+const b1 = cube([0,0], 10)`
+    const subStr = 'pos, scale'
+    const subStrIndex = code.indexOf(subStr)
+    const sourceRange: [number, number] = [
+      subStrIndex,
+      subStrIndex + 'pos'.length,
+    ]
+
+    const ast = parse(code)
+    const nodePath = getNodePathFromSourceRange(ast, sourceRange)
+    const node = getNodeFromPath<Identifier>(ast, nodePath).node
+
+    expect(nodePath).toEqual([
+      ['body', ''],
+      [0, 'index'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
+      ['init', ''],
+      ['params', 'FunctionExpression'],
+      [0, 'index'],
+    ])
+    expect(node.type).toBe('Identifier')
+    expect(node.name).toBe('pos')
+  })
+  it('gets path right for deep within function definition body', () => {
+    const code = `fn cube = (pos, scale) => {
+  const sg = startSketchAt(pos)
+    |> line([0, scale], %)
+    |> line([scale, 0], %)
+    |> line([0, -scale], %)
+
+  return sg
+}
+
+const b1 = cube([0,0], 10)`
+    const subStr = 'scale, 0'
+    const subStrIndex = code.indexOf(subStr)
+    const sourceRange: [number, number] = [
+      subStrIndex,
+      subStrIndex + 'scale'.length,
+    ]
+
+    const ast = parse(code)
+    const nodePath = getNodePathFromSourceRange(ast, sourceRange)
+    const node = getNodeFromPath<Identifier>(ast, nodePath).node
+    expect(nodePath).toEqual([
+      ['body', ''],
+      [0, 'index'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
+      ['init', ''],
+      ['body', 'FunctionExpression'],
+      ['body', 'FunctionExpression'],
+      [0, 'index'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
+      ['init', ''],
+      ['body', 'PipeExpression'],
+      [2, 'index'],
+      ['arguments', 'CallExpression'],
+      [0, 'index'],
+      ['elements', 'ArrayExpression'],
+      [0, 'index'],
+    ])
+    expect(node.type).toBe('Identifier')
+    expect(node.name).toBe('scale')
+  })
 })
--- a/src/lang/modifyAst.test.ts
+++ b/src/lang/modifyAst.test.ts
@ -1,4 +1,4 @@
-import { parser_wasm } from './abstractSyntaxTree'
+import { parse, recast, initPromise } from './wasm'
 import {
  createLiteral,
  createIdentifier,
@ -13,8 +13,6 @@ import {
  giveSketchFnCallTag,
  moveValueIntoNewVariable,
 } from './modifyAst'
-import { recast } from './recast'
-import { initPromise } from './rust'
 import { enginelessExecutor } from '../lib/testHelpers'

 beforeAll(() => initPromise)
@ -126,7 +124,7 @@ function giveSketchFnCallTagTestHelper(
  // giveSketchFnCallTag inputs and outputs an ast, which is very verbose for testing
  // this wrapper changes the input and output to code
  // making it more of an integration test, but easier to read the test intention is the goal
-  const ast = parser_wasm(code)
+  const ast = parse(code)
  const start = code.indexOf(searchStr)
  const range: [number, number] = [start, start + searchStr.length]
  const { modifiedAst, tag, isTagExisting } = giveSketchFnCallTag(ast, range)
@ -197,7 +195,7 @@ const part001 = startSketchAt([-1.2, 4.83])
 const yo2 = hmm([identifierGuy + 5])
 show(part001)`
  it('should move a binary expression into a new variable', async () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const startIndex = code.indexOf('100 + 100') + 1
    const { modifiedAst } = moveValueIntoNewVariable(
@ -211,7 +209,7 @@ show(part001)`
    expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
  })
  it('should move a value into a new variable', async () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const startIndex = code.indexOf('2.8') + 1
    const { modifiedAst } = moveValueIntoNewVariable(
@ -225,7 +223,7 @@ show(part001)`
    expect(newCode).toContain(`line([newVar, 0], %)`)
  })
  it('should move a callExpression into a new variable', async () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const startIndex = code.indexOf('def(')
    const { modifiedAst } = moveValueIntoNewVariable(
@ -239,7 +237,7 @@ show(part001)`
    expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
  })
  it('should move a binary expression with call expression into a new variable', async () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const startIndex = code.indexOf('jkl(') + 1
    const { modifiedAst } = moveValueIntoNewVariable(
@ -253,7 +251,7 @@ show(part001)`
    expect(newCode).toContain(`angledLine([newVar, 3.09], %)`)
  })
  it('should move a identifier into a new variable', async () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const startIndex = code.indexOf('identifierGuy +') + 1
    const { modifiedAst } = moveValueIntoNewVariable(
--- a/src/lang/modifyAst.ts
+++ b/src/lang/modifyAst.ts
@ -14,14 +14,15 @@ import {
  ObjectExpression,
  UnaryExpression,
  BinaryExpression,
-} from './abstractSyntaxTreeTypes'
+  PathToNode,
+  ProgramMemory,
+} from './wasm'
 import {
  findAllPreviousVariables,
  getNodeFromPath,
  getNodePathFromSourceRange,
  isNodeSafeToReplace,
 } from './queryAst'
-import { PathToNode, ProgramMemory } from './executor'
 import {
  addTagForSketchOnFace,
  getFirstArg,
@ -321,7 +322,7 @@ export function extrudeSketch(
    [0, 'index'],
  ]
  return {
-    modifiedAst: addToShow(_node, name),
+    modifiedAst: node,
    pathToNode: [...pathToNode.slice(0, -1), [showCallIndex, 'index']],
    pathToExtrudeArg,
  }
--- a/src/lang/queryAst.test.ts
+++ b/src/lang/queryAst.test.ts
@ -1,11 +1,10 @@
-import { parser_wasm } from './abstractSyntaxTree'
+import { parse, recast, initPromise } from './wasm'
 import {
  findAllPreviousVariables,
  isNodeSafeToReplace,
  isTypeInValue,
  getNodePathFromSourceRange,
 } from './queryAst'
-import { initPromise } from './rust'
 import { enginelessExecutor } from '../lib/testHelpers'
 import {
  createArrayExpression,
@ -13,7 +12,6 @@ import {
  createLiteral,
  createPipeSubstitution,
 } from './modifyAst'
-import { recast } from './recast'

 beforeAll(() => initPromise)

@ -36,7 +34,7 @@ const variableBelowShouldNotBeIncluded = 3

 show(part001)`
    const rangeStart = code.indexOf('// selection-range-7ish-before-this') - 7
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)

    const { variables, bodyPath, insertIndex } = findAllPreviousVariables(
@ -70,7 +68,7 @@ const yo = 5 + 6
 const yo2 = hmm([identifierGuy + 5])
 show(part001)`
  it('find a safe binaryExpression', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('100 + 100') + 2
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -84,7 +82,7 @@ show(part001)`
    expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
  })
  it('find a safe Identifier', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('abc')
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -92,7 +90,7 @@ show(part001)`
    expect(code.slice(result.value.start, result.value.end)).toBe('abc')
  })
  it('find a safe CallExpression', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('def')
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -106,7 +104,7 @@ show(part001)`
    expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
  })
  it('find an UNsafe CallExpression, as it has a PipeSubstitution', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('ghi')
    const range: [number, number] = [rangeStart, rangeStart]
    const result = isNodeSafeToReplace(ast, range)
@ -115,7 +113,7 @@ show(part001)`
    expect(code.slice(result.value.start, result.value.end)).toBe('ghi(%)')
  })
  it('find an UNsafe Identifier, as it is a callee', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('ine([2.8,')
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(false)
@ -125,7 +123,7 @@ show(part001)`
    )
  })
  it("find a safe BinaryExpression that's assigned to a variable", () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('5 + 6') + 1
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -139,7 +137,7 @@ show(part001)`
    expect(outCode).toContain(`const yo = replaceName`)
  })
  it('find a safe BinaryExpression that has a CallExpression within', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('jkl') + 1
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -155,7 +153,7 @@ show(part001)`
    expect(outCode).toContain(`angledLine([replaceName, 3.09], %)`)
  })
  it('find a safe BinaryExpression within a CallExpression', () => {
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const rangeStart = code.indexOf('identifierGuy') + 1
    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart])
    expect(result.isSafe).toBe(true)
@ -203,7 +201,7 @@ show(part001)`
  it('finds the second line when cursor is put at the end', () => {
    const searchLn = `line([0.94, 2.61], %)`
    const sourceIndex = code.indexOf(searchLn) + searchLn.length
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const result = getNodePathFromSourceRange(ast, [sourceIndex, sourceIndex])
    expect(result).toEqual([
      ['body', ''],
@ -218,7 +216,7 @@ show(part001)`
  it('finds the last line when cursor is put at the end', () => {
    const searchLn = `line([-0.21, -1.4], %)`
    const sourceIndex = code.indexOf(searchLn) + searchLn.length
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const result = getNodePathFromSourceRange(ast, [sourceIndex, sourceIndex])
    const expected = [
      ['body', ''],
--- a/src/lang/queryAst.ts
+++ b/src/lang/queryAst.ts
@ -1,4 +1,3 @@
-import { PathToNode, ProgramMemory, SketchGroup, SourceRange } from './executor'
 import { Selection, ToolTip } from '../useStore'
 import {
  BinaryExpression,
@ -10,7 +9,11 @@ import {
  VariableDeclaration,
  ReturnStatement,
  ArrayExpression,
-} from './abstractSyntaxTreeTypes'
+  PathToNode,
+  ProgramMemory,
+  SketchGroup,
+  SourceRange,
+} from './wasm'
 import { createIdentifier, splitPathAtLastIndex } from './modifyAst'
 import { getSketchSegmentFromSourceRange } from './std/sketchConstraints'
 import { getAngle } from '../lib/utils'
@ -239,7 +242,29 @@ function moreNodePathFromSourceRange(
    }
    return path
  }
-  console.error('not implemented')
+  if (_node.type === 'FunctionExpression' && isInRange) {
+    for (let i = 0; i < _node.params.length; i++) {
+      const param = _node.params[i]
+      if (param.start <= start && param.end >= end) {
+        path.push(['params', 'FunctionExpression'])
+        path.push([i, 'index'])
+        return moreNodePathFromSourceRange(param, sourceRange, path)
+      }
+    }
+    if (_node.body.start <= start && _node.body.end >= end) {
+      path.push(['body', 'FunctionExpression'])
+      const fnBody = _node.body.body
+      for (let i = 0; i < fnBody.length; i++) {
+        const statement = fnBody[i]
+        if (statement.start <= start && statement.end >= end) {
+          path.push(['body', 'FunctionExpression'])
+          path.push([i, 'index'])
+          return moreNodePathFromSourceRange(statement, sourceRange, path)
+        }
+      }
+    }
+  }
+  console.error('not implemented: ' + node.type)
  return path
 }

--- a/src/lang/recast.test.ts
+++ b/src/lang/recast.test.ts
@ -1,8 +1,5 @@
-import { recast } from './recast'
-import { parser_wasm } from './abstractSyntaxTree'
-import { Program } from './abstractSyntaxTreeTypes'
+import { parse, Program, recast, initPromise } from './wasm'
 import fs from 'node:fs'
-import { initPromise } from './rust'

 beforeAll(() => initPromise)

@ -366,6 +363,6 @@ describe('it recasts binary expression using brackets where needed', () => {
 // helpers

 function code2ast(code: string): { ast: Program } {
-  const ast = parser_wasm(code)
+  const ast = parse(code)
  return { ast }
 }
--- a/src/lang/recast.ts
+++ b/src/lang/recast.ts
@ -1,13 +0,0 @@
-import { Program } from './abstractSyntaxTreeTypes'
-import { recast_wasm } from '../wasm-lib/pkg/wasm_lib'
-
-export const recast = (ast: Program): string => {
-  try {
-    const s: string = recast_wasm(JSON.stringify(ast))
-    return s
-  } catch (e) {
-    // TODO: do something real with the error.
-    console.log('recast', e)
-    throw e
-  }
-}
--- a/src/lang/rust.ts
+++ b/src/lang/rust.ts
@ -1,20 +0,0 @@
-import init from '../wasm-lib/pkg/wasm_lib'
-
-const initialise = async () => {
-  const baseUrl =
-    typeof window === 'undefined'
-      ? 'http://127.0.0.1:3000'
-      : window.location.origin.includes('tauri://localhost')
-      ? 'tauri://localhost'
-      : window.location.origin.includes('localhost')
-      ? 'http://localhost:3000'
-      : window.location.origin && window.location.origin !== 'null'
-      ? window.location.origin
-      : 'http://localhost:3000'
-  const fullUrl = baseUrl + '/wasm_lib_bg.wasm'
-  const input = await fetch(fullUrl)
-  const buffer = await input.arrayBuffer()
-  return init(buffer)
-}
-
-export const initPromise = initialise()
--- a/src/lang/std/engineConnection.ts
+++ b/src/lang/std/engineConnection.ts
@ -1,4 +1,9 @@
-import { ProgramMemory, SourceRange } from 'lang/executor'
+import {
+  ProgramMemory,
+  SourceRange,
+  Program,
+  VariableDeclarator,
+} from 'lang/wasm'
 import { Selections } from 'useStore'
 import { VITE_KC_API_WS_MODELING_URL, VITE_KC_CONNECTION_TIMEOUT_MS } from 'env'
 import { Models } from '@kittycad/lib'
@ -6,7 +11,6 @@ import { exportSave } from 'lib/exportSave'
 import { v4 as uuidv4 } from 'uuid'
 import * as Sentry from '@sentry/react'
 import { getNodeFromPath, getNodePathFromSourceRange } from 'lang/queryAst'
-import { Program, VariableDeclarator } from 'lang/abstractSyntaxTreeTypes'

 let lastMessage = ''

@ -23,6 +27,10 @@ interface ResultCommand extends CommandInfo {
  data: any
  raw: WebSocketResponse
 }
+interface FailedCommand extends CommandInfo {
+  type: 'failed'
+  errors: Models['FailureWebSocketResponse_type']['errors']
+}
 interface PendingCommand extends CommandInfo {
  type: 'pending'
  promise: Promise<any>
@ -30,7 +38,7 @@ interface PendingCommand extends CommandInfo {
 }

 export interface ArtifactMap {
-  [key: string]: ResultCommand | PendingCommand
+  [key: string]: ResultCommand | PendingCommand | FailedCommand
 }
 export interface SourceRangeMap {
  [key: string]: SourceRange
@ -41,6 +49,11 @@ interface NewTrackArgs {
  mediaStream: MediaStream
 }

+// This looks funny, I know. This is needed because node and the browser
+// disagree as to the type. In a browser it's a number, but in node it's a
+// "Timeout".
+type Timeout = ReturnType<typeof setTimeout>
+
 type ClientMetrics = Models['ClientMetrics_type']

 // EngineConnection encapsulates the connection(s) to the Engine
@ -52,6 +65,9 @@ export class EngineConnection {
  unreliableDataChannel?: RTCDataChannel

  private ready: boolean
+  private connecting: boolean
+  private dead: boolean
+  private failedConnTimeout: Timeout | null

  readonly url: string
  private readonly token?: string
@ -87,6 +103,9 @@ export class EngineConnection {
    this.url = url
    this.token = token
    this.ready = false
+    this.connecting = false
+    this.dead = false
+    this.failedConnTimeout = null
    this.onWebsocketOpen = onWebsocketOpen
    this.onDataChannelOpen = onDataChannelOpen
    this.onEngineConnectionOpen = onEngineConnectionOpen
@ -97,7 +116,10 @@ export class EngineConnection {
    // TODO(paultag): This ought to be tweakable.
    const pingIntervalMs = 10000

-    setInterval(() => {
+    let pingInterval = setInterval(() => {
+      if (this.dead) {
+        clearInterval(pingInterval)
+      }
      if (this.isReady()) {
        // When we're online, every 10 seconds, we'll attempt to put a 'ping'
        // command through the WebSocket connection. This will help both ends
@ -106,6 +128,24 @@ export class EngineConnection {
        this.send({ type: 'ping' })
      }
    }, pingIntervalMs)
+
+    const connectionTimeoutMs = VITE_KC_CONNECTION_TIMEOUT_MS
+    let connectInterval = setInterval(() => {
+      if (this.dead) {
+        clearInterval(connectInterval)
+        return
+      }
+      if (this.isReady()) {
+        return
+      }
+      console.log('connecting via retry')
+      this.connect()
+    }, connectionTimeoutMs)
+  }
+  // isConnecting will return true when connect has been called, but the full
+  // WebRTC is not online.
+  isConnecting() {
+    return this.connecting
  }
  // isReady will return true only when the WebRTC *and* WebSocket connection
  // are connected. During setup, the WebSocket connection comes online first,
@ -114,6 +154,10 @@ export class EngineConnection {
  isReady() {
    return this.ready
  }
+  tearDown() {
+    this.dead = true
+    this.close()
+  }
  // shouldTrace will return true when Sentry should be used to instrument
  // the Engine.
  shouldTrace() {
@ -125,8 +169,10 @@ export class EngineConnection {
  // This will attempt the full handshake, and retry if the connection
  // did not establish.
  connect() {
-    // TODO(paultag): make this safe to call multiple times, and figure out
-    // when a connection is in progress (state: connecting or something).
+    console.log('connect was called')
+    if (this.isConnecting() || this.isReady()) {
+      return
+    }

    // Information on the connect transaction

@ -314,6 +360,11 @@ export class EngineConnection {
            if (this.shouldTrace()) {
              iceSpan.resolve?.()
            }
+          } else if (this.pc?.iceConnectionState === 'failed') {
+            // failed is a terminal state; let's explicitly kill the
+            // connection to the server at this point.
+            console.log('failed to negotiate ice connection; restarting')
+            this.close()
          }
        })

@ -358,20 +409,6 @@ export class EngineConnection {
          })
        })
      }
-
-      // TODO(paultag): This ought to be both controllable, as well as something
-      // like exponential backoff to have some grace on the backend, as well as
-      // fix responsiveness for clients that had a weird network hiccup.
-      const connectionTimeoutMs = VITE_KC_CONNECTION_TIMEOUT_MS
-
-      setTimeout(() => {
-        if (this.isReady()) {
-          return
-        }
-        console.log('engine connection timeout on connection, retrying')
-        this.close()
-        this.connect()
-      }, connectionTimeoutMs)
    })

    this.pc.addEventListener('track', (event) => {
@ -459,8 +496,11 @@ export class EngineConnection {

        this.onDataChannelOpen(this)

-        this.onEngineConnectionOpen(this)
        this.ready = true
+        this.connecting = false
+        // Do this after we set the connection is ready to avoid errors when
+        // we try to send messages before the connection is ready.
+        this.onEngineConnectionOpen(this)
      })

      this.unreliableDataChannel.addEventListener('close', (event) => {
@ -474,6 +514,22 @@ export class EngineConnection {
      })
    })

+    const connectionTimeoutMs = VITE_KC_CONNECTION_TIMEOUT_MS
+
+    if (this.failedConnTimeout) {
+      console.log('clearing timeout before set')
+      clearTimeout(this.failedConnTimeout)
+      this.failedConnTimeout = null
+    }
+    console.log('timeout set')
+    this.failedConnTimeout = setTimeout(() => {
+      if (this.isReady()) {
+        return
+      }
+      console.log('engine connection timeout on connection, closing')
+      this.close()
+    }, connectionTimeoutMs)
+
    this.onConnectionStarted(this)
  }
  unreliableSend(message: object | string) {
@ -498,9 +554,15 @@ export class EngineConnection {
    this.pc = undefined
    this.unreliableDataChannel = undefined
    this.webrtcStatsCollector = undefined
+    if (this.failedConnTimeout) {
+      console.log('closed timeout in close')
+      clearTimeout(this.failedConnTimeout)
+      this.failedConnTimeout = null
+    }

    this.onClose(this)
    this.ready = false
+    this.connecting = false
  }
 }

@ -531,6 +593,9 @@ export class EngineCommandManager {
  outSequence = 1
  inSequence = 1
  engineConnection?: EngineConnection
+  // Folks should realize that wait for ready does not get called _everytime_
+  // the connection resets and restarts, it only gets called the first time.
+  // Be careful what you put here.
  waitForReady: Promise<void> = new Promise(() => {})
  private resolveReady = () => {}

@ -544,19 +609,36 @@ export class EngineCommandManager {
      [localUnsubscribeId: string]: (a: any) => void
    }
  } = {} as any
-  constructor({
+
+  constructor() {
+    this.engineConnection = undefined
+  }
+
+  start({
    setMediaStream,
    setIsStreamReady,
    width,
    height,
+    executeCode,
    token,
  }: {
    setMediaStream: (stream: MediaStream) => void
    setIsStreamReady: (isStreamReady: boolean) => void
    width: number
    height: number
+    executeCode: (code?: string, force?: boolean) => void
    token?: string
  }) {
+    if (width === 0 || height === 0) {
+      return
+    }
+
+    // If we already have an engine connection, just need to resize the stream.
+    if (this.engineConnection) {
+      this.handleResize({ streamWidth: width, streamHeight: height })
+      return
+    }
+
    this.waitForReady = new Promise((resolve) => {
      this.resolveReady = resolve
    })
@ -567,6 +649,32 @@ export class EngineCommandManager {
      onEngineConnectionOpen: () => {
        this.resolveReady()
        setIsStreamReady(true)
+
+        // Make the axis gizmo.
+        // We do this after the connection opened to avoid a race condition.
+        // Connected opened is the last thing that happens when the stream
+        // is ready.
+        // We also do this here because we want to ensure we create the gizmo
+        // and execute the code everytime the stream is restarted.
+        const gizmoId = uuidv4()
+        this.sendSceneCommand({
+          type: 'modeling_cmd_req',
+          cmd_id: gizmoId,
+          cmd: {
+            type: 'make_axes_gizmo',
+            clobber: false,
+            // If true, axes gizmo will be placed in the corner of the screen.
+            // If false, it will be placed at the origin of the scene.
+            gizmo_mode: true,
+          },
+        })
+
+        // We execute the code here to make sure if the stream was to
+        // restart in a session, we want to make sure to execute the code.
+        // We force it to re-execute the code because we want to make sure
+        // the code is executed everytime the stream is restarted.
+        // We pass undefined for the code so it reads from the current state.
+        executeCode(undefined, true)
      },
      onClose: () => {
        setIsStreamReady(false)
@ -617,6 +725,8 @@ export class EngineCommandManager {
              message.request_id
            ) {
              this.handleModelingCommand(message.resp, message.request_id)
+            } else if (!message.success && message.request_id) {
+              this.handleFailedModelingCommand(message)
            }
          }
        })
@ -636,6 +746,30 @@ export class EngineCommandManager {

    this.engineConnection?.connect()
  }
+  handleResize({
+    streamWidth,
+    streamHeight,
+  }: {
+    streamWidth: number
+    streamHeight: number
+  }) {
+    console.log('handleResize', streamWidth, streamHeight)
+    if (!this.engineConnection?.isReady()) {
+      return
+    }
+
+    const resizeCmd: EngineCommand = {
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'reconfigure_stream',
+        width: streamWidth,
+        height: streamHeight,
+        fps: 60,
+      },
+    }
+    this.engineConnection?.send(resizeCmd)
+  }
  handleModelingCommand(message: WebSocketResponse, id: string) {
    if (message.type !== 'modeling') {
      return
@ -673,8 +807,40 @@ export class EngineCommandManager {
      }
    }
  }
+  handleFailedModelingCommand({
+    request_id,
+    errors,
+  }: Models['FailureWebSocketResponse_type']) {
+    const id = request_id
+    if (!id) return
+    const command = this.artifactMap[id]
+    if (command && command.type === 'pending') {
+      const resolve = command.resolve
+      this.artifactMap[id] = {
+        type: 'failed',
+        range: command.range,
+        commandType: command.commandType,
+        parentId: command.parentId ? command.parentId : undefined,
+        errors,
+      }
+      resolve({
+        id,
+        commandType: command.commandType,
+        range: command.range,
+        errors,
+      })
+    } else {
+      this.artifactMap[id] = {
+        type: 'failed',
+        range: command.range,
+        commandType: command.commandType,
+        parentId: command.parentId ? command.parentId : undefined,
+        errors,
+      }
+    }
+  }
  tearDown() {
-    this.engineConnection?.close()
+    this.engineConnection?.tearDown()
  }
  startNewSession() {
    this.artifactMap = {}
@ -769,6 +935,14 @@ export class EngineCommandManager {
    })
  }
  sendSceneCommand(command: EngineCommand): Promise<any> {
+    if (this.engineConnection === undefined) {
+      return Promise.resolve()
+    }
+
+    if (!this.engineConnection?.isReady()) {
+      return Promise.resolve()
+    }
+
    if (
      command.type === 'modeling_cmd_req' &&
      command.cmd.type !== lastMessage
@ -776,10 +950,6 @@ export class EngineCommandManager {
      console.log('sending command', command.cmd.type)
      lastMessage = command.cmd.type
    }
-    if (!this.engineConnection?.isReady()) {
-      console.log('socket not ready')
-      return Promise.resolve()
-    }
    if (command.type !== 'modeling_cmd_req') return Promise.resolve()
    const cmd = command.cmd
    if (
@ -821,10 +991,12 @@ export class EngineCommandManager {
    range: SourceRange
    command: EngineCommand | string
  }): Promise<any> {
+    if (this.engineConnection === undefined) {
+      return Promise.resolve()
+    }
    this.sourceRangeMap[id] = range

    if (!this.engineConnection?.isReady()) {
-      console.log('socket not ready')
      return Promise.resolve()
    }
    this.engineConnection?.send(command)
@ -867,6 +1039,9 @@ export class EngineCommandManager {
    rangeStr: string,
    commandStr: string
  ): Promise<any> {
+    if (this.engineConnection === undefined) {
+      return Promise.resolve()
+    }
    if (id === undefined) {
      throw new Error('id is undefined')
    }
@ -890,6 +1065,8 @@ export class EngineCommandManager {
    }
    if (command.type === 'result') {
      return command.data
+    } else if (command.type === 'failed') {
+      return Promise.resolve(command.errors)
    }
    return command.promise
  }
@ -915,6 +1092,9 @@ export class EngineCommandManager {
    }
  }
  private async fixIdMappings(ast: Program, programMemory: ProgramMemory) {
+    if (this.engineConnection === undefined) {
+      return
+    }
    /* This is a temporary solution since the cmd_ids that are sent through when
    sending 'extend_path' ids are not used as the segment ids.

@ -994,3 +1174,5 @@ export class EngineCommandManager {
    })
  }
 }
+
+export const engineCommandManager = new EngineCommandManager()
--- a/src/lang/std/sketch.test.ts
+++ b/src/lang/std/sketch.test.ts
@ -6,13 +6,9 @@ import {
  getXComponent,
  addCloseToPipe,
 } from './sketch'
-import { parser_wasm } from '../abstractSyntaxTree'
+import { parse, recast, initPromise } from '../wasm'
 import { getNodePathFromSourceRange } from '../queryAst'
-import { recast } from '../recast'
 import { enginelessExecutor } from '../../lib/testHelpers'
-import { initPromise } from '../rust'
-
-beforeAll(() => initPromise)

 const eachQuad: [number, [number, number]][] = [
  [-315, [1, 1]],
@ -29,6 +25,8 @@ const eachQuad: [number, [number, number]][] = [
  [675, [1, -1]],
 ]

+beforeAll(() => initPromise)
+
 describe('testing getYComponent', () => {
  it('should return the vertical component of a vector correctly when given angles in each quadrant (and with angles < 0, or > 360)', () => {
    const expected: [number, number][] = []
@ -106,7 +104,7 @@ show(mySketch001)
 `
    const code = genCode(lineToChange)
    const expectedCode = genCode(lineAfterChange)
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const sourceStart = code.indexOf(lineToChange)
    const { modifiedAst } = changeSketchArguments(
@ -144,7 +142,7 @@ const mySketch001 = startSketchAt([0, 0])
  |> lineTo([-1.59, -1.54], %)
  |> lineTo([0.46, -5.82], %)
 show(mySketch001)`
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const sourceStart = code.indexOf(lineToChange)
    expect(sourceStart).toBe(66)
@ -205,7 +203,7 @@ describe('testing addTagForSketchOnFace', () => {
 show(mySketch001)
 `
    const code = genCode(originalLine)
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const programMemory = await enginelessExecutor(ast)
    const sourceStart = code.indexOf(originalLine)
    const sourceRange: [number, number] = [
--- a/src/lang/std/sketch.ts
+++ b/src/lang/std/sketch.ts
@ -4,9 +4,6 @@ import {
  SketchGroup,
  SourceRange,
  PathToNode,
-  MemoryItem,
-} from '../executor'
-import {
  Program,
  PipeExpression,
  CallExpression,
@ -14,7 +11,7 @@ import {
  Value,
  Literal,
  VariableDeclaration,
-} from '../abstractSyntaxTreeTypes'
+} from '../wasm'
 import {
  getNodeFromPath,
  getNodeFromPathCurry,
@ -38,7 +35,6 @@ import {
  findUniqueName,
 } from '../modifyAst'
 import { roundOff, getLength, getAngle } from '../../lib/utils'
-import { getSketchSegmentFromSourceRange } from './sketchConstraints'
 import { perpendicularDistance } from 'sketch-helpers'

 export type Coords2d = [number, number]
--- a/src/lang/std/sketchConstraints.test.ts
+++ b/src/lang/std/sketchConstraints.test.ts
@ -1,12 +1,9 @@
-import { parser_wasm } from '../abstractSyntaxTree'
-import { SketchGroup } from '../executor'
+import { parse, SketchGroup, recast, initPromise } from '../wasm'
 import {
  ConstraintType,
  getTransformInfos,
  transformAstSketchLines,
 } from './sketchcombos'
-import { recast } from '../recast'
-import { initPromise } from '../rust'
 import { getSketchSegmentFromSourceRange } from './sketchConstraints'
 import { Selection } from '../../useStore'
 import { enginelessExecutor } from '../../lib/testHelpers'
@ -31,7 +28,7 @@ async function testingSwapSketchFnCall({
    type: 'default',
    range: [startIndex, startIndex + callToSwap.length],
  }
-  const ast = parser_wasm(inputCode)
+  const ast = parse(inputCode)
  const programMemory = await enginelessExecutor(ast)
  const selections = {
    codeBasedSelections: [range],
@ -381,7 +378,7 @@ const part001 = startSketchAt([0, 0.04]) // segment-in-start
  |> xLine(3.54, %)
 show(part001)`
  it('normal case works', async () => {
-    const programMemory = await enginelessExecutor(parser_wasm(code))
+    const programMemory = await enginelessExecutor(parse(code))
    const index = code.indexOf('// normal-segment') - 7
    const { __geoMeta, ...segment } = getSketchSegmentFromSourceRange(
      programMemory.root['part001'] as SketchGroup,
@ -395,7 +392,7 @@ show(part001)`
    })
  })
  it('verify it works when the segment is in the `start` property', async () => {
-    const programMemory = await enginelessExecutor(parser_wasm(code))
+    const programMemory = await enginelessExecutor(parse(code))
    const index = code.indexOf('// segment-in-start') - 7
    const { __geoMeta, ...segment } = getSketchSegmentFromSourceRange(
      programMemory.root['part001'] as SketchGroup,
--- a/src/lang/std/sketchConstraints.ts
+++ b/src/lang/std/sketchConstraints.ts
@ -3,8 +3,10 @@ import {
  Program,
  VariableDeclarator,
  CallExpression,
-} from '../abstractSyntaxTreeTypes'
-import { SketchGroup, SourceRange, Path } from '../executor'
+  SketchGroup,
+  SourceRange,
+  Path,
+} from '../wasm'

 export function getSketchSegmentFromSourceRange(
  sketchGroup: SketchGroup,
--- a/src/lang/std/sketchcombos.test.ts
+++ b/src/lang/std/sketchcombos.test.ts
@ -1,5 +1,4 @@
-import { parser_wasm } from '../abstractSyntaxTree'
-import { Value } from '../abstractSyntaxTreeTypes'
+import { parse, Value, recast, initPromise } from '../wasm'
 import {
  getConstraintType,
  getTransformInfos,
@ -8,10 +7,8 @@ import {
  ConstraintType,
  getConstraintLevelFromSourceRange,
 } from './sketchcombos'
-import { initPromise } from '../rust'
 import { Selections, ToolTip } from '../../useStore'
 import { enginelessExecutor } from '../../lib/testHelpers'
-import { recast } from '../../lang/recast'

 beforeAll(() => initPromise)

@ -63,7 +60,7 @@ describe('testing getConstraintType', () => {
 function getConstraintTypeFromSourceHelper(
  code: string
 ): ReturnType<typeof getConstraintType> {
-  const ast = parser_wasm(code)
+  const ast = parse(code)
  const args = (ast.body[0] as any).expression.arguments[0].elements as [
    Value,
    Value
@ -74,7 +71,7 @@ function getConstraintTypeFromSourceHelper(
 function getConstraintTypeFromSourceHelper2(
  code: string
 ): ReturnType<typeof getConstraintType> {
-  const ast = parser_wasm(code)
+  const ast = parse(code)
  const arg = (ast.body[0] as any).expression.arguments[0] as Value
  const fnName = (ast.body[0] as any).expression.callee.name as ToolTip
  return getConstraintType(arg, fnName)
@ -199,7 +196,7 @@ const part001 = startSketchAt([0, 0])
 show(part001)
 `
  it('should transform the ast', async () => {
-    const ast = parser_wasm(inputScript)
+    const ast = parse(inputScript)
    const selectionRanges: Selections['codeBasedSelections'] = inputScript
      .split('\n')
      .filter((ln) => ln.includes('//'))
@ -286,7 +283,7 @@ const part001 = startSketchAt([0, 0])
  |> angledLineToY([301, myVar], %) // select for vertical constraint 10
 show(part001)
 `
-    const ast = parser_wasm(inputScript)
+    const ast = parse(inputScript)
    const selectionRanges: Selections['codeBasedSelections'] = inputScript
      .split('\n')
      .filter((ln) => ln.includes('// select for horizontal constraint'))
@ -344,7 +341,7 @@ const part001 = startSketchAt([0, 0])
  |> yLineTo(myVar, %) // select for vertical constraint 10
 show(part001)
 `
-    const ast = parser_wasm(inputScript)
+    const ast = parse(inputScript)
    const selectionRanges: Selections['codeBasedSelections'] = inputScript
      .split('\n')
      .filter((ln) => ln.includes('// select for vertical constraint'))
@ -435,7 +432,7 @@ async function helperThing(
  linesOfInterest: string[],
  constraint: ConstraintType
 ): Promise<string> {
-  const ast = parser_wasm(inputScript)
+  const ast = parse(inputScript)
  const selectionRanges: Selections['codeBasedSelections'] = inputScript
    .split('\n')
    .filter((ln) =>
@ -498,7 +495,7 @@ const part001 = startSketchAt([-0.01, -0.05])
  |> xLine(-3.43 + 0, %) // full
  |> angledLineOfXLength([243 + 0, 1.2 + 0], %) // full
 show(part001)`
-    const ast = parser_wasm(code)
+    const ast = parse(code)
    const constraintLevels: ReturnType<
      typeof getConstraintLevelFromSourceRange
    >[] = ['full', 'partial', 'free']
--- a/src/lang/std/sketchcombos.ts
+++ b/src/lang/std/sketchcombos.ts
@ -6,7 +6,9 @@ import {
  Value,
  BinaryPart,
  VariableDeclarator,
-} from '../abstractSyntaxTreeTypes'
+  PathToNode,
+  ProgramMemory,
+} from '../wasm'
 import {
  getNodeFromPath,
  getNodeFromPathCurry,
@ -25,10 +27,8 @@ import {
  giveSketchFnCallTag,
 } from '../modifyAst'
 import { createFirstArg, getFirstArg, replaceSketchLine } from './sketch'
-import { PathToNode, ProgramMemory } from '../executor'
 import { getSketchSegmentFromSourceRange } from './sketchConstraints'
 import { getAngle, roundOff, normaliseAngle } from '../../lib/utils'
-import { MemoryItem } from 'wasm-lib/kcl/bindings/MemoryItem'

 type LineInputsType =
  | 'xAbsolute'
@ -1279,7 +1279,7 @@ export function getTransformInfos(
    }) as TransformInfo[]
    return theTransforms
  } catch (error) {
-    console.log(error)
+    console.log('error', error)
    return []
  }
 }
--- a/src/lang/std/std.test.ts
+++ b/src/lang/std/std.test.ts
@ -1,6 +1,5 @@
-import { parser_wasm } from '../abstractSyntaxTree'
+import { parse, initPromise } from '../wasm'
 import { enginelessExecutor } from '../../lib/testHelpers'
-import { initPromise } from '../rust'

 beforeAll(() => initPromise)

@ -17,9 +16,9 @@ describe('testing angledLineThatIntersects', () => {
 }, %)
 const intersect = segEndX('yo2', part001)
 show(part001)`
-    const { root } = await enginelessExecutor(parser_wasm(code('-1')))
+    const { root } = await enginelessExecutor(parse(code('-1')))
    expect(root.intersect.value).toBe(1 + Math.sqrt(2))
-    const { root: noOffset } = await enginelessExecutor(parser_wasm(code('0')))
+    const { root: noOffset } = await enginelessExecutor(parse(code('0')))
    expect(noOffset.intersect.value).toBeCloseTo(1)
  })
 })
--- a/src/lang/std/stdTypes.ts
+++ b/src/lang/std/stdTypes.ts
@ -1,7 +1,12 @@
-import { ProgramMemory, Path, SourceRange } from '../executor'
-import { Program, Value } from '../abstractSyntaxTreeTypes'
+import {
+  ProgramMemory,
+  Path,
+  SourceRange,
+  Program,
+  Value,
+  PathToNode,
+} from '../wasm'
 import { ToolTip } from '../../useStore'
-import { PathToNode } from '../executor'
 import { EngineCommandManager } from './engineConnection'

 export interface InternalFirstArg {
--- a/src/lang/tokeniser.test.ts
+++ b/src/lang/tokeniser.test.ts
@ -1,5 +1,4 @@
-import { lexer, asyncLexer } from './tokeniser'
-import { initPromise } from './rust'
+import { lexer, initPromise } from './wasm'

 beforeAll(() => initPromise)

@ -10,9 +9,9 @@ describe('testing lexer', () => {
    const code3 = `const yo = 45 /* this is a comment
 const ya = 6 */
 const yi=45`
-    expect(await asyncLexer(code)).toEqual(lexer(code))
-    expect(await asyncLexer(code2)).toEqual(lexer(code2))
-    expect(await asyncLexer(code3)).toEqual(lexer(code3))
+    expect(lexer(code)).toEqual(lexer(code))
+    expect(lexer(code2)).toEqual(lexer(code2))
+    expect(lexer(code3)).toEqual(lexer(code3))
  })
  it('test lexer', () => {
    expect(stringSummaryLexer('1  + 2')).toEqual([
--- a/src/lang/tokeniser.ts
+++ b/src/lang/tokeniser.ts
@ -1,28 +0,0 @@
-import { lexer_js } from '../wasm-lib/pkg/wasm_lib'
-import { initPromise } from './rust'
-import { Token } from '../wasm-lib/kcl/bindings/Token'
-
-export type { Token } from '../wasm-lib/kcl/bindings/Token'
-
-export async function asyncLexer(str: string): Promise<Token[]> {
-  await initPromise
-  try {
-    const tokens: Token[] = lexer_js(str)
-    return tokens
-  } catch (e) {
-    // TODO: do something real with the error.
-    console.log('lexer', e)
-    throw e
-  }
-}
-
-export function lexer(str: string): Token[] {
-  try {
-    const tokens: Token[] = lexer_js(str)
-    return tokens
-  } catch (e) {
-    // TODO: do something real with the error.
-    console.log('lexer', e)
-    throw e
-  }
-}
--- a/src/lang/util.ts
+++ b/src/lang/util.ts
@ -1,6 +1,5 @@
 import { Selections, StoreState } from '../useStore'
-import { Program } from './abstractSyntaxTreeTypes'
-import { PathToNode } from './executor'
+import { Program, PathToNode } from './wasm'
 import { getNodeFromPath } from './queryAst'

 export function updateCursors(
--- a/src/lang/wasm.ts
+++ b/src/lang/wasm.ts
@ -0,0 +1,215 @@
+import init, {
+  parse_wasm,
+  recast_wasm,
+  execute_wasm,
+  lexer_wasm,
+  modify_ast_for_sketch_wasm,
+} from '../wasm-lib/pkg/wasm_lib'
+import { KCLError } from './errors'
+import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
+import {
+  EngineCommandManager,
+  ArtifactMap,
+  SourceRangeMap,
+} from './std/engineConnection'
+import { ProgramReturn } from '../wasm-lib/kcl/bindings/ProgramReturn'
+import { MemoryItem } from '../wasm-lib/kcl/bindings/MemoryItem'
+import type { Program } from '../wasm-lib/kcl/bindings/Program'
+import type { Token } from '../wasm-lib/kcl/bindings/Token'
+
+export type { Program } from '../wasm-lib/kcl/bindings/Program'
+export type { Value } from '../wasm-lib/kcl/bindings/Value'
+export type { ObjectExpression } from '../wasm-lib/kcl/bindings/ObjectExpression'
+export type { MemberExpression } from '../wasm-lib/kcl/bindings/MemberExpression'
+export type { PipeExpression } from '../wasm-lib/kcl/bindings/PipeExpression'
+export type { VariableDeclaration } from '../wasm-lib/kcl/bindings/VariableDeclaration'
+export type { PipeSubstitution } from '../wasm-lib/kcl/bindings/PipeSubstitution'
+export type { Identifier } from '../wasm-lib/kcl/bindings/Identifier'
+export type { UnaryExpression } from '../wasm-lib/kcl/bindings/UnaryExpression'
+export type { BinaryExpression } from '../wasm-lib/kcl/bindings/BinaryExpression'
+export type { ReturnStatement } from '../wasm-lib/kcl/bindings/ReturnStatement'
+export type { ExpressionStatement } from '../wasm-lib/kcl/bindings/ExpressionStatement'
+export type { CallExpression } from '../wasm-lib/kcl/bindings/CallExpression'
+export type { VariableDeclarator } from '../wasm-lib/kcl/bindings/VariableDeclarator'
+export type { BinaryPart } from '../wasm-lib/kcl/bindings/BinaryPart'
+export type { Literal } from '../wasm-lib/kcl/bindings/Literal'
+export type { ArrayExpression } from '../wasm-lib/kcl/bindings/ArrayExpression'
+
+export type SyntaxType =
+  | 'Program'
+  | 'ExpressionStatement'
+  | 'BinaryExpression'
+  | 'CallExpression'
+  | 'Identifier'
+  | 'ReturnStatement'
+  | 'VariableDeclaration'
+  | 'VariableDeclarator'
+  | 'MemberExpression'
+  | 'ArrayExpression'
+  | 'ObjectExpression'
+  | 'ObjectProperty'
+  | 'FunctionExpression'
+  | 'PipeExpression'
+  | 'PipeSubstitution'
+  | 'Literal'
+  | 'NonCodeNode'
+  | 'UnaryExpression'
+
+export type { SourceRange } from '../wasm-lib/kcl/bindings/SourceRange'
+export type { Position } from '../wasm-lib/kcl/bindings/Position'
+export type { Rotation } from '../wasm-lib/kcl/bindings/Rotation'
+export type { Path } from '../wasm-lib/kcl/bindings/Path'
+export type { SketchGroup } from '../wasm-lib/kcl/bindings/SketchGroup'
+export type { MemoryItem } from '../wasm-lib/kcl/bindings/MemoryItem'
+export type { ExtrudeSurface } from '../wasm-lib/kcl/bindings/ExtrudeSurface'
+
+// Initialise the wasm module.
+const initialise = async () => {
+  const baseUrl =
+    typeof window === 'undefined'
+      ? 'http://127.0.0.1:3000'
+      : window.location.origin.includes('tauri://localhost')
+      ? 'tauri://localhost'
+      : window.location.origin.includes('localhost')
+      ? 'http://localhost:3000'
+      : window.location.origin && window.location.origin !== 'null'
+      ? window.location.origin
+      : 'http://localhost:3000'
+  const fullUrl = baseUrl + '/wasm_lib_bg.wasm'
+  const input = await fetch(fullUrl)
+  const buffer = await input.arrayBuffer()
+  return init(buffer)
+}
+
+export const initPromise = initialise()
+
+export const rangeTypeFix = (ranges: number[][]): [number, number][] =>
+  ranges.map(([start, end]) => [start, end])
+
+export const parse = (code: string): Program => {
+  try {
+    const program: Program = parse_wasm(code)
+    return program
+  } catch (e: any) {
+    const parsed: RustKclError = JSON.parse(e.toString())
+    const kclError = new KCLError(
+      parsed.kind,
+      parsed.msg,
+      rangeTypeFix(parsed.sourceRanges)
+    )
+
+    console.log(kclError)
+    throw kclError
+  }
+}
+
+export type PathToNode = [string | number, string][]
+
+interface Memory {
+  [key: string]: MemoryItem
+}
+
+export interface ProgramMemory {
+  root: Memory
+  return: ProgramReturn | null
+}
+
+export const executor = async (
+  node: Program,
+  programMemory: ProgramMemory = { root: {}, return: null },
+  engineCommandManager: EngineCommandManager,
+  // work around while the gemotry is still be stored on the frontend
+  // will be removed when the stream UI is added.
+  tempMapCallback: (a: {
+    artifactMap: ArtifactMap
+    sourceRangeMap: SourceRangeMap
+  }) => void = () => {}
+): Promise<ProgramMemory> => {
+  engineCommandManager.startNewSession()
+  const _programMemory = await _executor(
+    node,
+    programMemory,
+    engineCommandManager
+  )
+  const { artifactMap, sourceRangeMap } =
+    await engineCommandManager.waitForAllCommands(node, _programMemory)
+  tempMapCallback({ artifactMap, sourceRangeMap })
+
+  engineCommandManager.endSession()
+  return _programMemory
+}
+
+export const _executor = async (
+  node: Program,
+  programMemory: ProgramMemory = { root: {}, return: null },
+  engineCommandManager: EngineCommandManager
+): Promise<ProgramMemory> => {
+  try {
+    const memory: ProgramMemory = await execute_wasm(
+      JSON.stringify(node),
+      JSON.stringify(programMemory),
+      engineCommandManager
+    )
+    return memory
+  } catch (e: any) {
+    const parsed: RustKclError = JSON.parse(e.toString())
+    const kclError = new KCLError(
+      parsed.kind,
+      parsed.msg,
+      rangeTypeFix(parsed.sourceRanges)
+    )
+
+    console.log(kclError)
+    throw kclError
+  }
+}
+
+export const recast = (ast: Program): string => {
+  try {
+    const s: string = recast_wasm(JSON.stringify(ast))
+    return s
+  } catch (e) {
+    // TODO: do something real with the error.
+    console.log('recast error', e)
+    throw e
+  }
+}
+
+export function lexer(str: string): Token[] {
+  try {
+    const tokens: Token[] = lexer_wasm(str)
+    return tokens
+  } catch (e) {
+    // TODO: do something real with the error.
+    console.log('lexer error', e)
+    throw e
+  }
+}
+
+export const modifyAstForSketch = async (
+  engineCommandManager: EngineCommandManager,
+  ast: Program,
+  variableName: string,
+  engineId: string
+): Promise<Program> => {
+  try {
+    const updatedAst: Program = await modify_ast_for_sketch_wasm(
+      engineCommandManager,
+      JSON.stringify(ast),
+      variableName,
+      engineId
+    )
+
+    return updatedAst
+  } catch (e: any) {
+    const parsed: RustKclError = JSON.parse(e.toString())
+    const kclError = new KCLError(
+      parsed.kind,
+      parsed.msg,
+      rangeTypeFix(parsed.sourceRanges)
+    )
+
+    console.log(kclError)
+    throw kclError
+  }
+}
--- a/src/lib/exportSave.ts
+++ b/src/lib/exportSave.ts
@ -39,6 +39,6 @@ export async function exportSave(data: ArrayBuffer) {
    }
  } catch (e) {
    // TODO: do something real with the error.
-    console.log('export', e)
+    console.log('export error', e)
  }
 }
--- a/src/lib/tauriFS.ts
+++ b/src/lib/tauriFS.ts
@ -36,7 +36,7 @@ export async function initializeProjectDirectory(directory: string) {
  try {
    docDirectory = await documentDir()
  } catch (e) {
-    console.log(e)
+    console.log('error', e)
    docDirectory = await homeDir() // seems to work better on Linux
  }

--- a/src/lib/testHelpers.ts
+++ b/src/lib/testHelpers.ts
@ -1,10 +1,11 @@
-import { Program } from '../lang/abstractSyntaxTreeTypes'
-import { ProgramMemory, _executor } from '../lang/executor'
+import { Program, ProgramMemory, _executor, SourceRange } from '../lang/wasm'
 import {
  EngineCommandManager,
  EngineCommand,
 } from '../lang/std/engineConnection'
-import { SourceRange } from 'lang/executor'
+import { Models } from '@kittycad/lib'
+
+type WebSocketResponse = Models['OkWebSocketResponseData_type']

 class MockEngineCommandManager {
  constructor(mockParams: {
@ -23,7 +24,13 @@ class MockEngineCommandManager {
    range: SourceRange
    command: EngineCommand
  }): Promise<any> {
-    return Promise.resolve()
+    const response: WebSocketResponse = {
+      type: 'modeling',
+      data: {
+        modeling_response: { type: 'empty' },
+      },
+    }
+    return Promise.resolve(JSON.stringify(response))
  }
  sendModelingCommandFromWasm(
    id: string,
@ -66,11 +73,13 @@ export async function executor(
  ast: Program,
  pm: ProgramMemory = { root: {}, return: null }
 ): Promise<ProgramMemory> {
-  const engineCommandManager = new EngineCommandManager({
+  const engineCommandManager = new EngineCommandManager()
+  engineCommandManager.start({
    setIsStreamReady: () => {},
    setMediaStream: () => {},
-    width: 100,
-    height: 100,
+    width: 0,
+    height: 0,
+    executeCode: () => {},
  })
  await engineCommandManager.waitForReady
  engineCommandManager.startNewSession()
--- a/src/lib/utils.test.ts
+++ b/src/lib/utils.test.ts
@ -1,5 +1,5 @@
 import { isOverlap, roundOff } from './utils'
-import { SourceRange } from '../lang/executor'
+import { SourceRange } from '../lang/wasm'

 describe('testing isOverlapping', () => {
  testBothOrders([0, 3], [3, 10])
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@ -1,4 +1,4 @@
-import { SourceRange } from '../lang/executor'
+import { SourceRange } from '../lang/wasm'

 export function isOverlap(a: SourceRange, b: SourceRange) {
  const [startingRange, secondRange] = a[0] < b[0] ? [a, b] : [b, a]
--- a/src/machines/settingsMachine.ts
+++ b/src/machines/settingsMachine.ts
@ -2,6 +2,7 @@ import { assign, createMachine } from 'xstate'
 import { CommandBarMeta } from '../lib/commands'
 import { Themes, getSystemTheme, setThemeClass } from '../lib/theme'
 import { CameraSystem, cameraSystems } from 'lib/cameraControls'
+import { Models } from '@kittycad/lib'

 export const DEFAULT_PROJECT_NAME = 'project-$nnn'

@ -11,11 +12,11 @@ export enum UnitSystem {
 }

 export const baseUnits = {
-  imperial: ['in', 'ft'],
+  imperial: ['in', 'ft', 'yd'],
  metric: ['mm', 'cm', 'm'],
 } as const

-export type BaseUnit = 'in' | 'ft' | 'mm' | 'cm' | 'm'
+export type BaseUnit = Models['UnitLength_type']

 export const baseUnitsUnion = Object.values(baseUnits).flatMap((v) => v)

--- a/src/useStore.ts
+++ b/src/useStore.ts
@ -1,24 +1,25 @@
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 import { addLineHighlight, EditorView } from './editor/highlightextension'
-import { parser_wasm } from './lang/abstractSyntaxTree'
-import { Program } from './lang/abstractSyntaxTreeTypes'
-import { getNodeFromPath } from './lang/queryAst'
-import { enginelessExecutor } from './lib/testHelpers'
 import {
+  parse,
+  Program,
+  _executor,
+  recast,
  ProgramMemory,
  Position,
  PathToNode,
  Rotation,
  SourceRange,
-} from './lang/executor'
-import { recast } from './lang/recast'
+} from './lang/wasm'
+import { getNodeFromPath } from './lang/queryAst'
+import { enginelessExecutor } from './lib/testHelpers'
 import { EditorSelection } from '@codemirror/state'
 import { EngineCommandManager } from './lang/std/engineConnection'
 import { KCLError } from './lang/errors'
 import { deferExecution } from 'lib/utils'
-import { _executor } from './lang/executor'
 import { bracket } from 'lib/exampleKcl'
+import { engineCommandManager } from './lang/std/engineConnection'

 export type Selection = {
  type: 'default' | 'line-end' | 'line-mid'
@ -156,14 +157,12 @@ export interface StoreState {
  code: string
  setCode: (code: string) => void
  deferredSetCode: (code: string) => void
-  executeCode: (code?: string) => void
+  executeCode: (code?: string, force?: boolean) => void
  formatCode: () => void
  programMemory: ProgramMemory
  setProgramMemory: (programMemory: ProgramMemory) => void
  isShiftDown: boolean
  setIsShiftDown: (isShiftDown: boolean) => void
-  engineCommandManager?: EngineCommandManager
-  setEngineCommandManager: (engineCommandManager: EngineCommandManager) => void
  mediaStream?: MediaStream
  setMediaStream: (mediaStream: MediaStream) => void
  isStreamReady: boolean
@ -222,11 +221,12 @@ export const useStore = create<StoreState>()(
            editorView.dispatch({ effects: addLineHighlight.of(selection) })
          }
        },
-        executeCode: async (code) => {
+        executeCode: async (code, force) => {
          const result = await executeCode({
            code: code || get().code,
            lastAst: get().ast,
-            engineCommandManager: get().engineCommandManager,
+            engineCommandManager: engineCommandManager,
+            force,
          })
          if (!result.isChange) {
            return
@ -332,8 +332,6 @@ export const useStore = create<StoreState>()(
        executeAst: async (ast) => {
          const _ast = ast || get().ast
          if (!get().isStreamReady) return
-          const engineCommandManager = get().engineCommandManager!
-          if (!engineCommandManager) return

          set({ isExecuting: true })
          const { logs, errors, programMemory } = await executeAst({
@ -350,8 +348,6 @@ export const useStore = create<StoreState>()(
        executeAstMock: async (ast) => {
          const _ast = ast || get().ast
          if (!get().isStreamReady) return
-          const engineCommandManager = get().engineCommandManager!
-          if (!engineCommandManager) return

          const { logs, errors, programMemory } = await executeAst({
            ast: _ast,
@ -371,7 +367,7 @@ export const useStore = create<StoreState>()(
          { focusPath, callBack = () => {} } = {}
        ) => {
          const newCode = recast(ast)
-          const astWithUpdatedSource = parser_wasm(newCode)
+          const astWithUpdatedSource = parse(newCode)
          callBack(astWithUpdatedSource)

          set({
@ -427,7 +423,7 @@ export const useStore = create<StoreState>()(
        },
        formatCode: async () => {
          const code = get().code
-          const ast = parser_wasm(code)
+          const ast = parse(code)
          const newCode = recast(ast)
          set({ code: newCode, ast })
        },
@ -435,8 +431,6 @@ export const useStore = create<StoreState>()(
        setProgramMemory: (programMemory) => set({ programMemory }),
        isShiftDown: false,
        setIsShiftDown: (isShiftDown) => set({ isShiftDown }),
-        setEngineCommandManager: (engineCommandManager) =>
-          set({ engineCommandManager }),
        setMediaStream: (mediaStream) => set({ mediaStream }),
        isStreamReady: false,
        setIsStreamReady: (isStreamReady) => set({ isStreamReady }),
@ -454,7 +448,9 @@ export const useStore = create<StoreState>()(
        fileId: '',
        setFileId: (fileId) => set({ fileId }),
        streamDimensions: { streamWidth: 1280, streamHeight: 720 },
-        setStreamDimensions: (streamDimensions) => set({ streamDimensions }),
+        setStreamDimensions: (streamDimensions) => {
+          set({ streamDimensions })
+        },
        isExecuting: false,
        setIsExecuting: (isExecuting) => set({ isExecuting }),

@ -516,10 +512,12 @@ async function executeCode({
  engineCommandManager,
  code,
  lastAst,
+  force,
 }: {
  code: string
  lastAst: Program
-  engineCommandManager?: EngineCommandManager
+  engineCommandManager: EngineCommandManager
+  force?: boolean
 }): Promise<
  | {
      logs: string[]
@ -532,14 +530,14 @@ async function executeCode({
 > {
  let ast: Program
  try {
-    ast = parser_wasm(code)
+    ast = parse(code)
  } catch (e) {
    let errors: KCLError[] = []
    let logs: string[] = [JSON.stringify(e)]
    if (e instanceof KCLError) {
      errors = [e]
      logs = []
-      if (e.msg === 'file is empty') engineCommandManager?.endSession()
+      if (e.msg === 'file is empty') engineCommandManager.endSession()
    }
    return {
      isChange: true,
@ -562,7 +560,7 @@ async function executeCode({
  }
  // Check if the ast we have is equal to the ast in the storage.
  // If it is, we don't need to update the ast.
-  if (!engineCommandManager || JSON.stringify(ast) === JSON.stringify(lastAst))
+  if (JSON.stringify(ast) === JSON.stringify(lastAst) && !force)
    return { isChange: false }

  const { logs, errors, programMemory } = await executeAst({
--- a/src/wasm-lib/.config/nextest.toml
+++ b/src/wasm-lib/.config/nextest.toml
@ -6,10 +6,10 @@
 serial-integration = { max-threads = 4 }

 [profile.default]
-slow-timeout = { period = "10s", terminate-after = 1 }
+slow-timeout = { period = "60s", terminate-after = 1 }

 [profile.ci]
-slow-timeout = { period = "60s", terminate-after = 10 }
+slow-timeout = { period = "120s", terminate-after = 10 }

 [[profile.default.overrides]]
 filter = "test(serial_test_)"
--- a/src/wasm-lib/Cargo.lock
+++ b/src/wasm-lib/Cargo.lock
@ -71,9 +71,9 @@ checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"

 [[package]]
 name = "anstream"
-version = "0.5.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
+checksum = "f6cd65a4b849ace0b7f6daeebcc1a1d111282227ca745458c61dbf670e52a597"
 dependencies = [
 "anstyle",
 "anstyle-parse",
@ -109,9 +109,9 @@ dependencies = [

 [[package]]
 name = "anstyle-wincon"
-version = "2.1.0"
+version = "3.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
+checksum = "0238ca56c96dfa37bdf7c373c8886dd591322500aceeeccdb2216fe06dc2f796"
 dependencies = [
 "anstyle",
 "windows-sys 0.48.0",
@ -148,6 +148,17 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "async-recursion"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.37",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.73"
@ -217,13 +228,16 @@ checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2"

 [[package]]
 name = "bigdecimal"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6773ddc0eafc0e509fb60e48dff7f450f8e674a0686ae8605e8d9901bd5eefa"
+checksum = "454bca3db10617b88b566f205ed190aedb0e0e6dd4cad61d3988a72e8c5594cb"
 dependencies = [
+ "autocfg",
+ "libm",
 "num-bigint",
 "num-integer",
 "num-traits",
+ "serde",
 ]

 [[package]]
@ -426,9 +440,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.4.4"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1d7b8d5ec32af0fadc644bf1fd509a688c2103b185644bb1e29d164e0703136"
+checksum = "d04704f56c2cde07f43e8e2c154b43f216dc5c92fc98ada720177362f953b956"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -436,9 +450,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.4.4"
+version = "4.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5179bb514e4d7c2051749d8fcefa2ed6d06a9f4e6d69faf3805f5d80b8cf8d56"
+checksum = "0e231faeaca65ebd1ea3c737966bf858971cd38c3849107aa3ea7de90a804e45"
 dependencies = [
 "anstream",
 "anstyle",
@ -681,6 +695,20 @@ dependencies = [
 "syn 2.0.37",
 ]

+[[package]]
+name = "derive-docs"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c357dec14992ba88803535217ed83d6f6cd80efcb8fa8e3f8a30a9b84fadc1c7"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "serde",
+ "serde_tokenstream",
+ "syn 2.0.37",
+]
+
 [[package]]
 name = "diff"
 version = "0.1.13"
@ -774,9 +802,9 @@ dependencies = [

 [[package]]
 name = "expectorate"
-version = "1.0.7"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "710ab6a2d57038a835d66f78d5af3fa5d27c1ec4682f823b9203c48826cb0591"
+checksum = "de6f19b25bdfa2747ae775f37cd109c31f1272d4e4c83095be0727840aa1d75f"
 dependencies = [
 "console",
 "newline-converter",
@ -1362,15 +1390,16 @@ dependencies = [

 [[package]]
 name = "kcl-lib"
-version = "0.1.30"
+version = "0.1.32"
 dependencies = [
 "anyhow",
+ "async-recursion",
 "async-trait",
 "bson",
 "clap",
 "criterion",
 "dashmap",
- "derive-docs",
+ "derive-docs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "expectorate",
 "futures",
 "itertools 0.11.0",
@ -1379,7 +1408,6 @@ dependencies = [
 "lazy_static",
 "parse-display",
 "pretty_assertions",
- "regex",
 "reqwest",
 "schemars",
 "serde",
@ -1393,17 +1421,19 @@ dependencies = [
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
+ "winnow",
 ]

 [[package]]
 name = "kittycad"
-version = "0.2.25"
+version = "0.2.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9cf962b1e81a0b4eb923a727e761b40672cbacc7f5f0b75e13579d346352bc7"
+checksum = "35b2f9302648dbb06fd7121687f9505fc3179eba84111a06d76b246e3158f5dc"
 dependencies = [
 "anyhow",
 "async-trait",
 "base64 0.21.4",
+ "bigdecimal",
 "bytes",
 "chrono",
 "data-encoding",
@ -1465,6 +1495,12 @@ dependencies = [
 "winapi",
 ]

+[[package]]
+name = "libm"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@ -1697,7 +1733,7 @@ checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
 [[package]]
 name = "openapitor"
 version = "0.0.9"
-source = "git+https://github.com/KittyCAD/kittycad.rs?branch=main#0d121f6881da91b4a30bee18bbfe50e4a2096073"
+source = "git+https://github.com/KittyCAD/kittycad.rs?branch=main#fa0345c514fcc9ae6cd74ae35c8e5c2800fec34f"
 dependencies = [
 "Inflector",
 "anyhow",
@ -1871,14 +1907,14 @@ dependencies = [

 [[package]]
 name = "phonenumber"
-version = "0.3.2+8.13.9"
+version = "0.3.3+8.13.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34749f64ea9d76f10cdc8a859588b57775f59177c7dd91f744d620bd62982d6f"
+checksum = "635f3e6288e4f01c049d89332a031bd74f25d64b6fb94703ca966e819488cd06"
 dependencies = [
 "bincode",
 "either",
 "fnv",
- "itertools 0.10.5",
+ "itertools 0.11.0",
 "lazy_static",
 "nom",
 "quick-xml",
@ -1886,6 +1922,7 @@ dependencies = [
 "regex-cache",
 "serde",
 "serde_derive",
+ "strum",
 "thiserror",
 ]

@ -2812,6 +2849,28 @@ dependencies = [
 "syn 2.0.37",
 ]

+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 1.0.109",
+]
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@ -2900,18 +2959,18 @@ dependencies = [

 [[package]]
 name = "thiserror"
-version = "1.0.48"
+version = "1.0.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d6d7a740b8a666a7e828dd00da9c0dc290dff53154ea77ac109281de90589b7"
+checksum = "1177e8c6d7ede7afde3585fd2513e611227efd6481bd78d2e82ba1ce16557ed4"
 dependencies = [
 "thiserror-impl",
 ]

 [[package]]
 name = "thiserror-impl"
-version = "1.0.48"
+version = "1.0.49"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49922ecae66cc8a249b77e68d1d0623c1b2c514f0060c27cdc68bd62a1219d35"
+checksum = "10712f02019e9288794769fba95cd6847df9874d49d871d062172f9dd41bc4cc"
 dependencies = [
 "proc-macro2",
 "quote",
@ -3036,9 +3095,9 @@ dependencies = [

 [[package]]
 name = "tokio-tungstenite"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b2dbec703c26b00d74844519606ef15d09a7d6857860f84ad223dec002ddea2"
+checksum = "212d5dcb2a1ce06d81107c3d0ffa3121fe974b73f068c8282cb1c32328113b6c"
 dependencies = [
 "futures-util",
 "log",
@ -3258,9 +3317,9 @@ dependencies = [

 [[package]]
 name = "tungstenite"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e862a1c4128df0112ab625f55cd5c934bcb4312ba80b39ae4b4835a3fd58e649"
+checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
 dependencies = [
 "byteorder",
 "bytes",
@ -3747,6 +3806,15 @@ version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

+[[package]]
+name = "winnow"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.50.0"
--- a/src/wasm-lib/Cargo.toml
+++ b/src/wasm-lib/Cargo.toml
@ -11,7 +11,7 @@ crate-type = ["cdylib"]
 bson = { version = "2.7.0", features = ["uuid-1", "chrono"] }
 gloo-utils = "0.2.0"
 kcl-lib = { path = "kcl" }
-kittycad = { version = "0.2.25", default-features = false, features = ["js"] }
+kittycad = { version = "0.2.27", default-features = false, features = ["js"] }
 serde_json = "1.0.107"
 uuid = { version = "1.4.1", features = ["v4", "js", "serde"] }
 wasm-bindgen = "0.2.87"
@ -20,7 +20,7 @@ wasm-bindgen-futures = "0.4.37"
 [dev-dependencies]
 anyhow = "1"
 image = "0.24.7"
-kittycad = "0.2.25"
+kittycad = "0.2.27"
 pretty_assertions = "1.4.0"
 reqwest = { version = "0.11.20", default-features = false }
 tokio = { version = "1.32.0", features = ["rt-multi-thread", "macros", "time"] }
--- a/src/wasm-lib/derive-docs/Cargo.toml
+++ b/src/wasm-lib/derive-docs/Cargo.toml
@ -19,6 +19,6 @@ serde_tokenstream = "0.2"
 syn = { version = "2.0.37", features = ["full"] }

 [dev-dependencies]
-expectorate = "1.0.7"
+expectorate = "1.1.0"
 openapitor = { git = "https://github.com/KittyCAD/kittycad.rs", branch = "main" }
 pretty_assertions = "1.4.0"
--- a/src/wasm-lib/derive-docs/src/lib.rs
+++ b/src/wasm-lib/derive-docs/src/lib.rs
@ -79,13 +79,6 @@ fn do_stdlib_inner(
        ));
    }

-    if ast.sig.asyncness.is_some() {
-        errors.push(Error::new_spanned(
-            &ast.sig.fn_token,
-            "stdlib functions must not be async",
-        ));
-    }
-
    if ast.sig.unsafety.is_some() {
        errors.push(Error::new_spanned(
            &ast.sig.unsafety,
@ -118,6 +111,7 @@ fn do_stdlib_inner(
    let fn_name = &ast.sig.ident;
    let fn_name_str = fn_name.to_string().replace("inner_", "");
    let fn_name_ident = format_ident!("{}", fn_name_str);
+    let boxed_fn_name_ident = format_ident!("boxed_{}", fn_name_str);
    let _visibility = &ast.vis;

    let (summary_text, description_text) = extract_doc_from_attrs(&ast.attrs);
@ -204,7 +198,10 @@ fn do_stdlib_inner(
            syn::FnArg::Typed(pat) => pat.ty.as_ref().into_token_stream(),
        };

-        let ty_string = ty.to_string().replace('&', "").replace("mut", "").replace(' ', "");
+        let mut ty_string = ty.to_string().replace('&', "").replace("mut", "").replace(' ', "");
+        if ty_string.starts_with("Args") {
+            ty_string = "Args".to_string();
+        }
        let ty_string = ty_string.trim().to_string();
        let ty_ident = if ty_string.starts_with("Vec<") {
            let ty_string = ty_string.trim_start_matches("Vec<").trim_end_matches('>');
@ -305,6 +302,14 @@ fn do_stdlib_inner(
        #description_doc_comment
        #const_struct

+        fn #boxed_fn_name_ident(
+            args: crate::std::Args,
+        ) -> std::pin::Pin<
+            Box<dyn std::future::Future<Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>>>,
+        > {
+            Box::pin(#fn_name_ident(args))
+        }
+
        impl #docs_crate::StdLibFn for #name_ident
        {
            fn name(&self) -> String {
@ -348,7 +353,7 @@ fn do_stdlib_inner(
            }

            fn std_lib_fn(&self) -> crate::std::StdFn {
-                #fn_name_ident
+                #boxed_fn_name_ident
            }

            fn clone_box(&self) -> Box<dyn #docs_crate::StdLibFn> {
--- a/src/wasm-lib/derive-docs/tests/box.gen
+++ b/src/wasm-lib/derive-docs/tests/box.gen
@ -7,6 +7,18 @@ pub(crate) struct Show {}
 #[allow(non_upper_case_globals, missing_docs)]
 #[doc = "Std lib function: show"]
 pub(crate) const Show: Show = Show {};
+fn boxed_show(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(show(args))
+}
+
 impl crate::docs::StdLibFn for Show {
    fn name(&self) -> String {
        "show".to_string()
@ -57,7 +69,7 @@ impl crate::docs::StdLibFn for Show {
    }

    fn std_lib_fn(&self) -> crate::std::StdFn {
-        show
+        boxed_show
    }

    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
--- a/src/wasm-lib/derive-docs/tests/lineTo.gen
+++ b/src/wasm-lib/derive-docs/tests/lineTo.gen
@ -7,6 +7,18 @@ pub(crate) struct LineTo {}
 #[allow(non_upper_case_globals, missing_docs)]
 #[doc = "Std lib function: lineTo"]
 pub(crate) const LineTo: LineTo = LineTo {};
+fn boxed_line_to(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(line_to(args))
+}
+
 impl crate::docs::StdLibFn for LineTo {
    fn name(&self) -> String {
        "lineTo".to_string()
@ -65,7 +77,7 @@ impl crate::docs::StdLibFn for LineTo {
    }

    fn std_lib_fn(&self) -> crate::std::StdFn {
-        line_to
+        boxed_line_to
    }

    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
--- a/src/wasm-lib/derive-docs/tests/min.gen
+++ b/src/wasm-lib/derive-docs/tests/min.gen
@ -7,6 +7,18 @@ pub(crate) struct Min {}
 #[allow(non_upper_case_globals, missing_docs)]
 #[doc = "Std lib function: min"]
 pub(crate) const Min: Min = Min {};
+fn boxed_min(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(min(args))
+}
+
 impl crate::docs::StdLibFn for Min {
    fn name(&self) -> String {
        "min".to_string()
@ -57,7 +69,7 @@ impl crate::docs::StdLibFn for Min {
    }

    fn std_lib_fn(&self) -> crate::std::StdFn {
-        min
+        boxed_min
    }

    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
--- a/src/wasm-lib/derive-docs/tests/show.gen
+++ b/src/wasm-lib/derive-docs/tests/show.gen
@ -7,6 +7,18 @@ pub(crate) struct Show {}
 #[allow(non_upper_case_globals, missing_docs)]
 #[doc = "Std lib function: show"]
 pub(crate) const Show: Show = Show {};
+fn boxed_show(
+    args: crate::std::Args,
+) -> std::pin::Pin<
+    Box<
+        dyn std::future::Future<
+            Output = anyhow::Result<crate::executor::MemoryItem, crate::errors::KclError>,
+        >,
+    >,
+> {
+    Box::pin(show(args))
+}
+
 impl crate::docs::StdLibFn for Show {
    fn name(&self) -> String {
        "show".to_string()
@ -52,7 +64,7 @@ impl crate::docs::StdLibFn for Show {
    }

    fn std_lib_fn(&self) -> crate::std::StdFn {
-        show
+        boxed_show
    }

    fn clone_box(&self) -> Box<dyn crate::docs::StdLibFn> {
--- a/src/wasm-lib/kcl/Cargo.toml
+++ b/src/wasm-lib/kcl/Cargo.toml
@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language"
-version = "0.1.30"
+version = "0.1.32"
 edition = "2021"
 license = "MIT"

@ -9,21 +9,22 @@ license = "MIT"

 [dependencies]
 anyhow = { version = "1.0.75", features = ["backtrace"] }
+async-recursion = "1.0.5"
 async-trait = "0.1.73"
-clap = { version = "4.4.3", features = ["cargo", "derive", "env", "unicode"], optional = true }
+clap = { version = "4.4.6", features = ["cargo", "derive", "env", "unicode"], optional = true }
 dashmap = "5.5.3"
-#derive-docs = { version = "0.1.4" }
-derive-docs = { path = "../derive-docs" }
-kittycad = { version = "0.2.25", default-features = false, features = ["js"] }
+derive-docs = { version = "0.1.4" }
+#derive-docs = { path = "../derive-docs" }
+kittycad = { version = "0.2.27", default-features = false, features = ["js"] }
 lazy_static = "1.4.0"
 parse-display = "0.8.2"
-regex = "1.7.1"
 schemars = { version = "0.8", features = ["impl_json_schema", "url", "uuid1"] }
 serde = { version = "1.0.188", features = ["derive"] }
 serde_json = "1.0.107"
-thiserror = "1.0.48"
+thiserror = "1.0.49"
 ts-rs = { version = "7", package = "ts-rs-json-value", features = ["serde-json-impl", "schemars-impl", "uuid-impl"] }
 uuid = { version = "1.4.1", features = ["v4", "js", "serde"] }
+winnow = "0.5.15"

 [target.'cfg(target_arch = "wasm32")'.dependencies]
 js-sys = { version = "0.3.64" }
@ -51,7 +52,7 @@ debug = true

 [dev-dependencies]
 criterion = "0.5.1"
-expectorate = "1.0.7"
+expectorate = "1.1.0"
 itertools = "0.11.0"
 pretty_assertions = "1.4.0"
 tokio = { version = "1.32.0", features = ["rt-multi-thread", "macros", "time"] }
--- a/src/wasm-lib/kcl/benches/compiler_benchmark.rs
+++ b/src/wasm-lib/kcl/benches/compiler_benchmark.rs
@ -1,12 +1,33 @@
-use criterion::{criterion_group, criterion_main, Criterion};
+use criterion::{black_box, criterion_group, criterion_main, Criterion};

-pub fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("parse + lex cube program", |b| b.iter(lex_and_parse_cube));
+pub fn bench_lex(c: &mut Criterion) {
+    c.bench_function("lex_cube", |b| b.iter(|| lex(CUBE_PROGRAM)));
+    c.bench_function("lex_big_kitt", |b| b.iter(|| lex(KITT_PROGRAM)));
+    c.bench_function("lex_pipes_on_pipes", |b| b.iter(|| lex(PIPES_PROGRAM)));
 }

-fn lex_and_parse_cube() {
-    let program = r#"
-fn cube = (pos, scale) => {
+pub fn bench_lex_parse(c: &mut Criterion) {
+    c.bench_function("parse_lex_cube", |b| b.iter(|| lex_and_parse(CUBE_PROGRAM)));
+    c.bench_function("parse_lex_big_kitt", |b| b.iter(|| lex_and_parse(KITT_PROGRAM)));
+    c.bench_function("parse_lex_pipes_on_pipes", |b| b.iter(|| lex_and_parse(PIPES_PROGRAM)));
+}
+
+fn lex(program: &str) {
+    black_box(kcl_lib::token::lexer(program));
+}
+
+fn lex_and_parse(program: &str) {
+    let tokens = kcl_lib::token::lexer(program);
+    let parser = kcl_lib::parser::Parser::new(tokens);
+    black_box(parser.ast().unwrap());
+}
+
+criterion_group!(benches, bench_lex, bench_lex_parse);
+criterion_main!(benches);
+
+const KITT_PROGRAM: &str = include_str!("../../tests/executor/inputs/kittycad_svg.kcl");
+const PIPES_PROGRAM: &str = include_str!("../../tests/executor/inputs/pipes_on_pipes.kcl");
+const CUBE_PROGRAM: &str = r#"fn cube = (pos, scale) => {
  const sg = startSketchAt(pos)
    |> line([0, scale], %)
    |> line([scale, 0], %)
@ -18,10 +39,3 @@ fn cube = (pos, scale) => {
 const b1 = cube([0,0], 10)
 const pt1 = b1[0]
 show(b1)"#;
-    let tokens = kcl_lib::tokeniser::lexer(program);
-    let parser = kcl_lib::parser::Parser::new(tokens);
-    parser.ast().unwrap();
-}
-
-criterion_group!(benches, criterion_benchmark);
-criterion_main!(benches);
--- a/src/wasm-lib/kcl/clippy.toml
+++ b/src/wasm-lib/kcl/clippy.toml
@ -0,0 +1 @@
+enum-variant-size-threshold = 24
--- a/src/wasm-lib/kcl/fuzz/Cargo.lock
+++ b/src/wasm-lib/kcl/fuzz/Cargo.lock
@ -44,54 +44,6 @@ dependencies = [
 "memchr",
 ]

-[[package]]
-name = "anstream"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c4c2c83f81532e5845a733998b6971faca23490340a418e9b72a3ec9de12ea"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
-dependencies = [
- "windows-sys",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
-dependencies = [
- "anstyle",
- "windows-sys",
-]
-
 [[package]]
 name = "anyhow"
 version = "1.0.75"
@ -123,6 +75,17 @@ dependencies = [
 "thiserror",
 ]

+[[package]]
+name = "async-recursion"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.37",
+]
+
 [[package]]
 name = "async-trait"
 version = "0.1.73"
@ -131,7 +94,7 @@ checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -179,6 +142,20 @@ version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"

+[[package]]
+name = "bigdecimal"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "454bca3db10617b88b566f205ed190aedb0e0e6dd4cad61d3988a72e8c5594cb"
+dependencies = [
+ "autocfg",
+ "libm",
+ "num-bigint",
+ "num-integer",
+ "num-traits",
+ "serde",
+]
+
 [[package]]
 name = "bincode"
 version = "1.3.3"
@ -284,54 +261,6 @@ dependencies = [
 "serde",
 ]

-[[package]]
-name = "clap"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a13b88d2c62ff462f88e4a121f17a82c1af05693a2f192b5c38d14de73c19f6"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bb9faaa7c2ef94b2743a21f5a29e6f0010dff4caa69ac8e9d6cf8b6fa74da08"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
- "unicase",
- "unicode-width",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
-
 [[package]]
 name = "convert_case"
 version = "0.6.0"
@ -403,16 +332,14 @@ checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946"

 [[package]]
 name = "derive-docs"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fe5c5ea065cfabc5a7c5e8ed616e369fbf108c4be01e0e5609bc9846a732664"
+version = "0.1.4"
 dependencies = [
 "convert_case",
 "proc-macro2",
 "quote",
 "serde",
 "serde_tokenstream",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -529,7 +456,7 @@ checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -769,11 +696,12 @@ dependencies = [

 [[package]]
 name = "kcl-lib"
-version = "0.1.24"
+version = "0.1.31"
 dependencies = [
 "anyhow",
+ "async-recursion",
+ "async-trait",
 "bson",
- "clap",
 "dashmap",
 "derive-docs",
 "futures",
@ -781,7 +709,6 @@ dependencies = [
 "kittycad",
 "lazy_static",
 "parse-display",
- "regex",
 "reqwest",
 "schemars",
 "serde",
@ -794,6 +721,8 @@ dependencies = [
 "uuid",
 "wasm-bindgen",
 "wasm-bindgen-futures",
+ "web-sys",
+ "winnow",
 ]

 [[package]]
@ -806,12 +735,13 @@ dependencies = [

 [[package]]
 name = "kittycad"
-version = "0.2.24"
+version = "0.2.26"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd2f78e95054c83ab77059fe0237b128e2b241b4b8e9466e452d701c2599f3d3"
+checksum = "e2623ee601ce203476229df3f9d3a14664cb43e3f7455e9ac8ed91aacaa6163d"
 dependencies = [
 "anyhow",
 "base64 0.21.3",
+ "bigdecimal",
 "bytes",
 "chrono",
 "data-encoding",
@ -850,6 +780,12 @@ dependencies = [
 "once_cell",
 ]

+[[package]]
+name = "libm"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
+
 [[package]]
 name = "linked-hash-map"
 version = "0.5.6"
@ -942,6 +878,27 @@ dependencies = [
 "minimal-lexical",
 ]

+[[package]]
+name = "num-bigint"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+dependencies = [
+ "autocfg",
+ "num-integer",
+ "num-traits",
+]
+
+[[package]]
+name = "num-integer"
+version = "0.1.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+dependencies = [
+ "autocfg",
+ "num-traits",
+]
+
 [[package]]
 name = "num-traits"
 version = "0.2.16"
@ -1034,7 +991,7 @@ dependencies = [
 "regex",
 "regex-syntax 0.7.5",
 "structmeta",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1045,9 +1002,9 @@ checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"

 [[package]]
 name = "phonenumber"
-version = "0.3.2+8.13.9"
+version = "0.3.3+8.13.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34749f64ea9d76f10cdc8a859588b57775f59177c7dd91f744d620bd62982d6f"
+checksum = "635f3e6288e4f01c049d89332a031bd74f25d64b6fb94703ca966e819488cd06"
 dependencies = [
 "bincode",
 "either",
@ -1060,6 +1017,7 @@ dependencies = [
 "regex-cache",
 "serde",
 "serde_derive",
+ "strum",
 "thiserror",
 ]

@ -1080,7 +1038,7 @@ checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1127,9 +1085,9 @@ dependencies = [

 [[package]]
 name = "proc-macro2"
-version = "1.0.66"
+version = "1.0.67"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
+checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
 dependencies = [
 "unicode-ident",
 ]
@ -1342,6 +1300,12 @@ dependencies = [
 "untrusted",
 ]

+[[package]]
+name = "rustversion"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
+
 [[package]]
 name = "ryu"
 version = "1.0.15"
@ -1359,10 +1323,11 @@ dependencies = [

 [[package]]
 name = "schemars"
-version = "0.8.13"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "763f8cd0d4c71ed8389c90cb8100cba87e763bd01a8e614d4f0af97bcd50a161"
+checksum = "1f7b0ce13155372a76ee2e1c5ffba1fe61ede73fbea5630d61eee6fac4929c0c"
 dependencies = [
+ "bigdecimal",
 "bytes",
 "chrono",
 "dyn-clone",
@ -1375,9 +1340,9 @@ dependencies = [

 [[package]]
 name = "schemars_derive"
-version = "0.8.13"
+version = "0.8.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0f696e21e10fa546b7ffb1c9672c6de8fbc7a81acf59524386d8639bf12737"
+checksum = "e85e2a16b12bdb763244c69ab79363d71db2b4b918a2def53f80b02e0574b13c"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1450,7 +1415,7 @@ checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1466,9 +1431,9 @@ dependencies = [

 [[package]]
 name = "serde_json"
-version = "1.0.105"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
+checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
 dependencies = [
 "indexmap 2.0.0",
 "itoa",
@ -1484,7 +1449,7 @@ checksum = "8725e1dfadb3a50f7e5ce0b1a540466f6ed3fe7a0fca2ac2b8b831d31316bd00"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1496,7 +1461,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1572,12 +1537,6 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
 [[package]]
 name = "structmeta"
 version = "0.2.0"
@ -1587,7 +1546,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "structmeta-derive",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1598,7 +1557,29 @@ checksum = "a60bcaff7397072dca0017d1db428e30d5002e00b6847703e2e42005c95fbe00"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
+]
+
+[[package]]
+name = "strum"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.24.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 1.0.109",
 ]

 [[package]]
@ -1614,9 +1595,9 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.31"
+version = "2.0.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "718fa2415bcb8d8bd775917a1bf12a7931b6dfa890753378538118181e0cb398"
+checksum = "7303ef2c05cd654186cb250d29049a24840ca25d2747c25c0381c8d9e2f582e8"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1655,7 +1636,7 @@ checksum = "49922ecae66cc8a249b77e68d1d0623c1b2c514f0060c27cdc68bd62a1219d35"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1728,7 +1709,7 @@ checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1822,7 +1803,7 @@ checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1851,7 +1832,7 @@ checksum = "5f4f31f56159e98206da9efd823404b79b6ef3143b4a7ab76e67b1751b25a4ab"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 ]

 [[package]]
@ -1891,15 +1872,15 @@ dependencies = [
 "Inflector",
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 "termcolor",
 ]

 [[package]]
 name = "tungstenite"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e862a1c4128df0112ab625f55cd5c934bcb4312ba80b39ae4b4835a3fd58e649"
+checksum = "9e3dac10fd62eaf6617d3a904ae222845979aec67c615d1c842b4002c7666fb9"
 dependencies = [
 "byteorder",
 "bytes",
@ -1921,15 +1902,6 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"

-[[package]]
-name = "unicase"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
-dependencies = [
- "version_check",
-]
-
 [[package]]
 name = "unicode-bidi"
 version = "0.3.13"
@ -1957,12 +1929,6 @@ version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"

-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
 [[package]]
 name = "untrusted"
 version = "0.7.1"
@ -1987,12 +1953,6 @@ version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"

-[[package]]
-name = "utf8parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
-
 [[package]]
 name = "uuid"
 version = "1.4.1"
@ -2046,7 +2006,7 @@ dependencies = [
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 "wasm-bindgen-shared",
 ]

@ -2080,7 +2040,7 @@ checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.31",
+ "syn 2.0.37",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]
@ -2198,6 +2158,15 @@ version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

+[[package]]
+name = "winnow"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "winreg"
 version = "0.50.0"
--- a/src/wasm-lib/kcl/src/ast/modify.rs
+++ b/src/wasm-lib/kcl/src/ast/modify.rs
@ -71,7 +71,7 @@ pub async fn modify_ast_for_sketch(

    // Let's get the path info.
    let resp = engine
-        .send_modeling_cmd_get_response(
+        .send_modeling_cmd(
            uuid::Uuid::new_v4(),
            SourceRange::default(),
            ModelingCmd::PathGetInfo { path_id: sketch_id },
@ -88,47 +88,6 @@ pub async fn modify_ast_for_sketch(
        }));
    };

-    /* // Let's try to get the children of the sketch.
-    let resp = engine
-        .send_modeling_cmd_get_response(
-            uuid::Uuid::new_v4(),
-            SourceRange::default(),
-            ModelingCmd::EntityGetAllChildUuids { entity_id: sketch_id },
-        )
-        .await?;
-    let kittycad::types::OkWebSocketResponseData::Modeling {
-        modeling_response: kittycad::types::OkModelingCmdResponse::EntityGetAllChildUuids { data: children_info },
-    } = &resp
-    else {
-        return Err(KclError::Engine(KclErrorDetails {
-            message: format!("Get child info response was not as expected: {:?}", resp),
-            source_ranges: vec![SourceRange::default()],
-        }));
-    };
-
-    println!("children_info: {:#?}", children_info);
-
-    // Let's try to get the parent id.
-    let resp = engine
-        .send_modeling_cmd_get_response(
-            uuid::Uuid::new_v4(),
-            SourceRange::default(),
-            ModelingCmd::EntityGetParentId { entity_id: sketch_id },
-        )
-        .await?;
-
-    let kittycad::types::OkWebSocketResponseData::Modeling {
-        modeling_response: kittycad::types::OkModelingCmdResponse::EntityGetParentId { data: parent_info },
-    } = &resp
-    else {
-        return Err(KclError::Engine(KclErrorDetails {
-            message: format!("Get parent id response was not as expected: {:?}", resp),
-            source_ranges: vec![SourceRange::default()],
-        }));
-    };
-
-    println!("parent_info: {:#?}", parent_info);*/
-
    // Now let's get the control points for all the segments.
    // TODO: We should probably await all these at once so we aren't going one by one.
    // But I guess this is fine for now.
@ -136,7 +95,7 @@ pub async fn modify_ast_for_sketch(
    let mut control_points = Vec::new();
    for segment in &path_info.segments {
        if let Some(command_id) = &segment.command_id {
-            let h = engine.send_modeling_cmd_get_response(
+            let h = engine.send_modeling_cmd(
                uuid::Uuid::new_v4(),
                SourceRange::default(),
                ModelingCmd::CurveGetControlPoints { curve_id: *command_id },
@ -207,7 +166,7 @@ pub async fn modify_ast_for_sketch(
    let recasted = program.recast(&FormatOptions::default(), 0);

    // Re-parse the ast so we get the correct source ranges.
-    let tokens = crate::tokeniser::lexer(&recasted);
+    let tokens = crate::token::lexer(&recasted);
    let parser = crate::parser::Parser::new(tokens);
    *program = parser.ast()?;

--- a/src/wasm-lib/kcl/src/ast/types.rs
+++ b/src/wasm-lib/kcl/src/ast/types.rs
@ -258,6 +258,23 @@ impl Program {
        }
    }

+    /// Replace a value with the new value, use the source range for matching the exact value.
+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for item in &mut self.body {
+            match item {
+                BodyItem::ExpressionStatement(ref mut expression_statement) => expression_statement
+                    .expression
+                    .replace_value(source_range, new_value.clone()),
+                BodyItem::VariableDeclaration(ref mut variable_declaration) => {
+                    variable_declaration.replace_value(source_range, new_value.clone())
+                }
+                BodyItem::ReturnStatement(ref mut return_statement) => {
+                    return_statement.argument.replace_value(source_range, new_value.clone())
+                }
+            }
+        }
+    }
+
    /// Get the variable declaration with the given name.
    pub fn get_variable(&self, name: &str) -> Option<&VariableDeclarator> {
        for item in &self.body {
@ -393,6 +410,27 @@ impl Value {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        if source_range == self.clone().into() {
+            *self = new_value;
+            return;
+        }
+
+        match self {
+            Value::BinaryExpression(ref mut bin_exp) => bin_exp.replace_value(source_range, new_value),
+            Value::ArrayExpression(ref mut array_exp) => array_exp.replace_value(source_range, new_value),
+            Value::ObjectExpression(ref mut obj_exp) => obj_exp.replace_value(source_range, new_value),
+            Value::MemberExpression(_) => {}
+            Value::Literal(_) => {}
+            Value::FunctionExpression(ref mut func_exp) => func_exp.replace_value(source_range, new_value),
+            Value::CallExpression(ref mut call_exp) => call_exp.replace_value(source_range, new_value),
+            Value::Identifier(_) => {}
+            Value::PipeExpression(ref mut pipe_exp) => pipe_exp.replace_value(source_range, new_value),
+            Value::UnaryExpression(ref mut unary_exp) => unary_exp.replace_value(source_range, new_value),
+            Value::PipeSubstitution(_) => {}
+        }
+    }
+
    pub fn start(&self) -> usize {
        match self {
            Value::Literal(literal) => literal.start(),
@ -538,6 +576,23 @@ impl BinaryPart {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        match self {
+            BinaryPart::Literal(_) => {}
+            BinaryPart::Identifier(_) => {}
+            BinaryPart::BinaryExpression(ref mut binary_expression) => {
+                binary_expression.replace_value(source_range, new_value)
+            }
+            BinaryPart::CallExpression(ref mut call_expression) => {
+                call_expression.replace_value(source_range, new_value)
+            }
+            BinaryPart::UnaryExpression(ref mut unary_expression) => {
+                unary_expression.replace_value(source_range, new_value)
+            }
+            BinaryPart::MemberExpression(_) => {}
+        }
+    }
+
    fn recast(&self, options: &FormatOptions, indentation_level: usize) -> String {
        match &self {
            BinaryPart::Literal(literal) => literal.recast(),
@ -571,11 +626,12 @@ impl BinaryPart {
        }
    }

-    pub fn get_result(
+    #[async_recursion::async_recursion(?Send)]
+    pub async fn get_result(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
        // stop the execution of the pipe.
@ -590,11 +646,13 @@ impl BinaryPart {
                Ok(value.clone())
            }
            BinaryPart::BinaryExpression(binary_expression) => {
-                binary_expression.get_result(memory, &mut new_pipe_info, engine)
+                binary_expression.get_result(memory, &mut new_pipe_info, engine).await
+            }
+            BinaryPart::CallExpression(call_expression) => {
+                call_expression.execute(memory, &mut new_pipe_info, engine).await
            }
-            BinaryPart::CallExpression(call_expression) => call_expression.execute(memory, &mut new_pipe_info, engine),
            BinaryPart::UnaryExpression(unary_expression) => {
-                unary_expression.get_result(memory, &mut new_pipe_info, engine)
+                unary_expression.get_result(memory, &mut new_pipe_info, engine).await
            }
            BinaryPart::MemberExpression(member_expression) => member_expression.get_result(memory),
        }
@ -798,6 +856,12 @@ impl CallExpression {
        })
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for arg in &mut self.arguments {
+            arg.replace_value(source_range, new_value.clone());
+        }
+    }
+
    fn recast(&self, options: &FormatOptions, indentation_level: usize, is_in_pipe: bool) -> String {
        format!(
            "{}({})",
@ -810,11 +874,12 @@ impl CallExpression {
        )
    }

-    pub fn execute(
+    #[async_recursion::async_recursion(?Send)]
+    pub async fn execute(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        let fn_name = self.callee.name.clone();

@ -828,7 +893,7 @@ impl CallExpression {
                    value.clone()
                }
                Value::BinaryExpression(binary_expression) => {
-                    binary_expression.get_result(memory, pipe_info, engine)?
+                    binary_expression.get_result(memory, pipe_info, engine).await?
                }
                Value::CallExpression(call_expression) => {
                    // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
@ -836,11 +901,15 @@ impl CallExpression {
                    // THIS IS IMPORTANT.
                    let mut new_pipe_info = pipe_info.clone();
                    new_pipe_info.is_in_pipe = false;
-                    call_expression.execute(memory, &mut new_pipe_info, engine)?
+                    call_expression.execute(memory, &mut new_pipe_info, engine).await?
                }
-                Value::UnaryExpression(unary_expression) => unary_expression.get_result(memory, pipe_info, engine)?,
-                Value::ObjectExpression(object_expression) => object_expression.execute(memory, pipe_info, engine)?,
-                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine)?,
+                Value::UnaryExpression(unary_expression) => {
+                    unary_expression.get_result(memory, pipe_info, engine).await?
+                }
+                Value::ObjectExpression(object_expression) => {
+                    object_expression.execute(memory, pipe_info, engine).await?
+                }
+                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine).await?,
                Value::PipeExpression(pipe_expression) => {
                    return Err(KclError::Semantic(KclErrorDetails {
                        message: format!("PipeExpression not implemented here: {:?}", pipe_expression),
@ -871,31 +940,28 @@ impl CallExpression {

        match &self.function {
            Function::StdLib { func } => {
-                /* let source_range: SourceRange = self.into();
-                println!(
-                    "Calling stdlib function: {}, source_range: {:?}, args: {:?}",
-                    fn_name, source_range, fn_args
-                );*/
                // Attempt to call the function.
-                let mut args = crate::std::Args::new(fn_args, self.into(), engine);
-                let result = func.std_lib_fn()(&mut args)?;
+                let args = crate::std::Args::new(fn_args, self.into(), engine.clone());
+                let result = func.std_lib_fn()(args).await?;
                if pipe_info.is_in_pipe {
                    pipe_info.index += 1;
                    pipe_info.previous_results.push(result);
-                    execute_pipe_body(memory, &pipe_info.body.clone(), pipe_info, self.into(), engine)
+                    execute_pipe_body(memory, &pipe_info.body.clone(), pipe_info, self.into(), engine).await
                } else {
                    Ok(result)
                }
            }
            Function::InMemory => {
-                let mem = memory.clone();
-                let func = mem.get(&fn_name, self.into())?;
-                let result = func.call_fn(&fn_args, &mem, engine)?.ok_or_else(|| {
-                    KclError::UndefinedValue(KclErrorDetails {
-                        message: format!("Result of function {} is undefined", fn_name),
-                        source_ranges: vec![self.into()],
-                    })
-                })?;
+                let func = memory.get(&fn_name, self.into())?;
+                let result = func
+                    .call_fn(fn_args, memory.clone(), engine.clone())
+                    .await?
+                    .ok_or_else(|| {
+                        KclError::UndefinedValue(KclErrorDetails {
+                            message: format!("Result of function {} is undefined", fn_name),
+                            source_ranges: vec![self.into()],
+                        })
+                    })?;

                let result = result.get_value()?;

@ -903,7 +969,7 @@ impl CallExpression {
                    pipe_info.index += 1;
                    pipe_info.previous_results.push(result);

-                    execute_pipe_body(memory, &pipe_info.body.clone(), pipe_info, self.into(), engine)
+                    execute_pipe_body(memory, &pipe_info.body.clone(), pipe_info, self.into(), engine).await
                } else {
                    Ok(result)
                }
@ -1009,6 +1075,12 @@ impl VariableDeclaration {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for declaration in &mut self.declarations {
+            declaration.init.replace_value(source_range, new_value.clone());
+        }
+    }
+
    /// Returns a value that includes the given character position.
    pub fn get_value_for_position(&self, pos: usize) -> Option<&Value> {
        for declaration in &self.declarations {
@ -1362,6 +1434,12 @@ impl ArrayExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for element in &mut self.elements {
+            element.replace_value(source_range, new_value.clone());
+        }
+    }
+
    pub fn get_constraint_level(&self) -> ConstraintLevel {
        if self.elements.is_empty() {
            return ConstraintLevel::Ignore {
@ -1424,11 +1502,12 @@ impl ArrayExpression {
        None
    }

-    pub fn execute(
+    #[async_recursion::async_recursion(?Send)]
+    pub async fn execute(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        let mut results = Vec::with_capacity(self.elements.len());

@ -1440,7 +1519,7 @@ impl ArrayExpression {
                    value.clone()
                }
                Value::BinaryExpression(binary_expression) => {
-                    binary_expression.get_result(memory, pipe_info, engine)?
+                    binary_expression.get_result(memory, pipe_info, engine).await?
                }
                Value::CallExpression(call_expression) => {
                    // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
@ -1448,12 +1527,16 @@ impl ArrayExpression {
                    // THIS IS IMPORTANT.
                    let mut new_pipe_info = pipe_info.clone();
                    new_pipe_info.is_in_pipe = false;
-                    call_expression.execute(memory, &mut new_pipe_info, engine)?
+                    call_expression.execute(memory, &mut new_pipe_info, engine).await?
                }
-                Value::UnaryExpression(unary_expression) => unary_expression.get_result(memory, pipe_info, engine)?,
-                Value::ObjectExpression(object_expression) => object_expression.execute(memory, pipe_info, engine)?,
-                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine)?,
-                Value::PipeExpression(pipe_expression) => pipe_expression.get_result(memory, pipe_info, engine)?,
+                Value::UnaryExpression(unary_expression) => {
+                    unary_expression.get_result(memory, pipe_info, engine).await?
+                }
+                Value::ObjectExpression(object_expression) => {
+                    object_expression.execute(memory, pipe_info, engine).await?
+                }
+                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine).await?,
+                Value::PipeExpression(pipe_expression) => pipe_expression.get_result(memory, pipe_info, engine).await?,
                Value::PipeSubstitution(pipe_substitution) => {
                    return Err(KclError::Semantic(KclErrorDetails {
                        message: format!("PipeSubstitution not implemented here: {:?}", pipe_substitution),
@ -1507,6 +1590,12 @@ impl ObjectExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for property in &mut self.properties {
+            property.value.replace_value(source_range, new_value.clone());
+        }
+    }
+
    pub fn get_constraint_level(&self) -> ConstraintLevel {
        if self.properties.is_empty() {
            return ConstraintLevel::Ignore {
@ -1569,11 +1658,12 @@ impl ObjectExpression {
        None
    }

-    pub fn execute(
+    #[async_recursion::async_recursion(?Send)]
+    pub async fn execute(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        let mut object = Map::new();
        for property in &self.properties {
@ -1584,7 +1674,7 @@ impl ObjectExpression {
                    value.clone()
                }
                Value::BinaryExpression(binary_expression) => {
-                    binary_expression.get_result(memory, pipe_info, engine)?
+                    binary_expression.get_result(memory, pipe_info, engine).await?
                }
                Value::CallExpression(call_expression) => {
                    // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
@ -1592,12 +1682,16 @@ impl ObjectExpression {
                    // THIS IS IMPORTANT.
                    let mut new_pipe_info = pipe_info.clone();
                    new_pipe_info.is_in_pipe = false;
-                    call_expression.execute(memory, &mut new_pipe_info, engine)?
+                    call_expression.execute(memory, &mut new_pipe_info, engine).await?
                }
-                Value::UnaryExpression(unary_expression) => unary_expression.get_result(memory, pipe_info, engine)?,
-                Value::ObjectExpression(object_expression) => object_expression.execute(memory, pipe_info, engine)?,
-                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine)?,
-                Value::PipeExpression(pipe_expression) => pipe_expression.get_result(memory, pipe_info, engine)?,
+                Value::UnaryExpression(unary_expression) => {
+                    unary_expression.get_result(memory, pipe_info, engine).await?
+                }
+                Value::ObjectExpression(object_expression) => {
+                    object_expression.execute(memory, pipe_info, engine).await?
+                }
+                Value::ArrayExpression(array_expression) => array_expression.execute(memory, pipe_info, engine).await?,
+                Value::PipeExpression(pipe_expression) => pipe_expression.get_result(memory, pipe_info, engine).await?,
                Value::PipeSubstitution(pipe_substitution) => {
                    return Err(KclError::Semantic(KclErrorDetails {
                        message: format!("PipeSubstitution not implemented here: {:?}", pipe_substitution),
@ -1946,6 +2040,11 @@ impl BinaryExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        self.left.replace_value(source_range, new_value.clone());
+        self.right.replace_value(source_range, new_value);
+    }
+
    pub fn get_constraint_level(&self) -> ConstraintLevel {
        let left_constraint_level = self.left.get_constraint_level();
        let right_constraint_level = self.right.get_constraint_level();
@ -2005,11 +2104,12 @@ impl BinaryExpression {
        None
    }

-    pub fn get_result(
+    #[async_recursion::async_recursion(?Send)]
+    pub async fn get_result(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
        // stop the execution of the pipe.
@ -2019,11 +2119,13 @@ impl BinaryExpression {

        let left_json_value = self
            .left
-            .get_result(memory, &mut new_pipe_info, engine)?
+            .get_result(memory, &mut new_pipe_info, engine)
+            .await?
            .get_json_value()?;
        let right_json_value = self
            .right
-            .get_result(memory, &mut new_pipe_info, engine)?
+            .get_result(memory, &mut new_pipe_info, engine)
+            .await?
            .get_json_value()?;

        // First check if we are doing string concatenation.
@ -2165,6 +2267,10 @@ impl UnaryExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        self.argument.replace_value(source_range, new_value);
+    }
+
    pub fn get_constraint_level(&self) -> ConstraintLevel {
        self.argument.get_constraint_level()
    }
@ -2173,11 +2279,11 @@ impl UnaryExpression {
        format!("{}{}", &self.operator, self.argument.recast(options, 0))
    }

-    pub fn get_result(
+    pub async fn get_result(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        // We DO NOT set this gloablly because if we did and this was called inside a pipe it would
        // stop the execution of the pipe.
@ -2188,7 +2294,8 @@ impl UnaryExpression {
        let num = parse_json_number_as_f64(
            &self
                .argument
-                .get_result(memory, &mut new_pipe_info, engine)?
+                .get_result(memory, &mut new_pipe_info, engine)
+                .await?
                .get_json_value()?,
            self.into(),
        )?;
@ -2259,6 +2366,12 @@ impl PipeExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        for value in &mut self.body {
+            value.replace_value(source_range, new_value.clone());
+        }
+    }
+
    pub fn get_constraint_level(&self) -> ConstraintLevel {
        if self.body.is_empty() {
            return ConstraintLevel::Ignore {
@ -2310,16 +2423,16 @@ impl PipeExpression {
        None
    }

-    pub fn get_result(
+    pub async fn get_result(
        &self,
        memory: &mut ProgramMemory,
        pipe_info: &mut PipeInfo,
-        engine: &mut EngineConnection,
+        engine: &EngineConnection,
    ) -> Result<MemoryItem, KclError> {
        // Reset the previous results.
        pipe_info.previous_results = vec![];
        pipe_info.index = 0;
-        execute_pipe_body(memory, &self.body, pipe_info, self.into(), engine)
+        execute_pipe_body(memory, &self.body, pipe_info, self.into(), engine).await
    }

    /// Rename all identifiers that have the old name to the new given name.
@ -2330,12 +2443,13 @@ impl PipeExpression {
    }
 }

-fn execute_pipe_body(
+#[async_recursion::async_recursion(?Send)]
+async fn execute_pipe_body(
    memory: &mut ProgramMemory,
    body: &[Value],
    pipe_info: &mut PipeInfo,
    source_range: SourceRange,
-    engine: &mut EngineConnection,
+    engine: &EngineConnection,
 ) -> Result<MemoryItem, KclError> {
    if pipe_info.index == body.len() {
        pipe_info.is_in_pipe = false;
@ -2360,15 +2474,15 @@ fn execute_pipe_body(

    match expression {
        Value::BinaryExpression(binary_expression) => {
-            let result = binary_expression.get_result(memory, pipe_info, engine)?;
+            let result = binary_expression.get_result(memory, pipe_info, engine).await?;
            pipe_info.previous_results.push(result);
            pipe_info.index += 1;
-            execute_pipe_body(memory, body, pipe_info, source_range, engine)
+            execute_pipe_body(memory, body, pipe_info, source_range, engine).await
        }
        Value::CallExpression(call_expression) => {
            pipe_info.is_in_pipe = true;
            pipe_info.body = body.to_vec();
-            call_expression.execute(memory, pipe_info, engine)
+            call_expression.execute(memory, pipe_info, engine).await
        }
        _ => {
            // Return an error this should not happen.
@ -2400,6 +2514,10 @@ impl FunctionExpression {
        }
    }

+    pub fn replace_value(&mut self, source_range: SourceRange, new_value: Value) {
+        self.body.replace_value(source_range, new_value);
+    }
+
    pub fn recast(&self, options: &FormatOptions, indentation_level: usize) -> String {
        // We don't want to end with a new line inside nested functions.
        let mut new_options = options.clone();
@ -2671,7 +2789,7 @@ fn ghi = (x) => {
 }

 show(part001)"#;
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();
        let symbols = program.get_lsp_symbols(code);
@ -2699,7 +2817,7 @@ show(part001)
        let some_program_string = r#"const part001 = startSketchAt([0.0, 5.0])
              |> line([0.4900857016, -0.0240763666], %)
    |> line([0.6804562304, 0.9087880491], %)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2718,7 +2836,7 @@ show(part001)
        let some_program_string = r#"const part001 = startSketchAt([0.0, 5.0])
              |> line([0.4900857016, -0.0240763666], %) // hello world
    |> line([0.6804562304, 0.9087880491], %)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2737,7 +2855,7 @@ show(part001)
              |> line([0.4900857016, -0.0240763666], %)
        // hello world
    |> line([0.6804562304, 0.9087880491], %)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2763,7 +2881,7 @@ show(part001)
  // this is also a comment
    return things
 }"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2800,7 +2918,7 @@ const mySk1 = startSketchAt([0, 0])
  |> ry(45, %)
  |> rx(45, %)
 // one more for good measure"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2839,7 +2957,7 @@ a comment between pipe expression statements */
  |> line([-0.42, -1.72], %)

 show(part001)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2865,7 +2983,7 @@ const yo = [
  "  hey oooooo really long long long"
 ]
 "#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2883,7 +3001,7 @@ const key = 'c'
 const things = "things"

 // this is also a comment"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2901,7 +3019,7 @@ const things = "things"
 // a comment
   "
 }"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2926,7 +3044,7 @@ const part001 = startSketchAt([0, 0])
       -angleToMatchLengthY('seg01', myVar, %),
       myVar
     ], %) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2952,7 +3070,7 @@ const part001 = startSketchAt([0, 0])
         myVar
      ], %) // ln-lineTo-yAbsolute should use angleToMatchLengthY helper
 "#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -2983,7 +3101,7 @@ fn ghi = (part001) => {
 }

 show(part001)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let mut program = parser.ast().unwrap();
        program.rename_symbol("mySuperCoolPart", 6);
@ -3014,7 +3132,7 @@ show(mySuperCoolPart)
        let some_program_string = r#"fn ghi = (x, y, z) => {
  return x
 }"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let mut program = parser.ast().unwrap();
        program.rename_symbol("newName", 10);
@ -3043,7 +3161,7 @@ const firstExtrude = startSketchAt([0,0])
  |> extrude(h, %)

 show(firstExtrude)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -3069,7 +3187,7 @@ show(firstExtrude)
    #[tokio::test(flavor = "multi_thread")]
    async fn test_recast_math_start_negative() {
        let some_program_string = r#"const myVar = -5 + 6"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

@ -3085,7 +3203,7 @@ const FOS = 2
 const sigmaAllow = 8
 const width = 20
 const thickness = sqrt(distance * p * FOS * 6 / (sigmaAllow * width))"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
+        let tokens = crate::token::lexer(some_program_string);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast().unwrap();

--- a/src/wasm-lib/kcl/src/engine/conn.rs
+++ b/src/wasm-lib/kcl/src/engine/conn.rs
@ -3,10 +3,11 @@

 use std::sync::Arc;

-use anyhow::Result;
+use anyhow::{anyhow, Result};
 use dashmap::DashMap;
 use futures::{SinkExt, StreamExt};
 use kittycad::types::{OkWebSocketResponseData, WebSocketRequest, WebSocketResponse};
+use tokio::sync::{mpsc, oneshot};
 use tokio_tungstenite::tungstenite::Message as WsMsg;

 use crate::{
@ -14,18 +15,13 @@ use crate::{
    errors::{KclError, KclErrorDetails},
 };

-#[derive(Debug)]
+type WebSocketTcpWrite = futures::stream::SplitSink<tokio_tungstenite::WebSocketStream<reqwest::Upgraded>, WsMsg>;
+#[derive(Debug, Clone)]
+#[allow(dead_code)] // for the TcpReadHandle
 pub struct EngineConnection {
-    tcp_write: futures::stream::SplitSink<tokio_tungstenite::WebSocketStream<reqwest::Upgraded>, WsMsg>,
-    tcp_read_handle: tokio::task::JoinHandle<Result<()>>,
+    engine_req_tx: mpsc::Sender<ToEngineReq>,
    responses: Arc<DashMap<uuid::Uuid, WebSocketResponse>>,
-}
-
-impl Drop for EngineConnection {
-    fn drop(&mut self) {
-        // Drop the read handle.
-        self.tcp_read_handle.abort();
-    }
+    tcp_read_handle: Arc<TcpReadHandle>,
 }

 pub struct TcpRead {
@ -46,16 +42,63 @@ impl TcpRead {
    }
 }

+#[derive(Debug)]
+pub struct TcpReadHandle {
+    handle: Arc<tokio::task::JoinHandle<Result<()>>>,
+}
+
+impl Drop for TcpReadHandle {
+    fn drop(&mut self) {
+        // Drop the read handle.
+        self.handle.abort();
+    }
+}
+
+/// Requests to send to the engine, and a way to await a response.
+struct ToEngineReq {
+    /// The request to send
+    req: WebSocketRequest,
+    /// If this resolves to Ok, the request was sent.
+    /// If this resolves to Err, the request could not be sent.
+    /// If this has not yet resolved, the request has not been sent yet.
+    request_sent: oneshot::Sender<Result<()>>,
+}
+
 impl EngineConnection {
+    /// Start waiting for incoming engine requests, and send each one over the WebSocket to the engine.
+    async fn start_write_actor(mut tcp_write: WebSocketTcpWrite, mut engine_req_rx: mpsc::Receiver<ToEngineReq>) {
+        while let Some(req) = engine_req_rx.recv().await {
+            let ToEngineReq { req, request_sent } = req;
+            let res = Self::inner_send_to_engine(req, &mut tcp_write).await;
+            let _ = request_sent.send(res);
+        }
+    }
+
+    /// Send the given `request` to the engine via the WebSocket connection `tcp_write`.
+    async fn inner_send_to_engine(request: WebSocketRequest, tcp_write: &mut WebSocketTcpWrite) -> Result<()> {
+        let msg = serde_json::to_string(&request).map_err(|e| anyhow!("could not serialize json: {e}"))?;
+        tcp_write
+            .send(WsMsg::Text(msg))
+            .await
+            .map_err(|e| anyhow!("could not send json over websocket: {e}"))?;
+        Ok(())
+    }
+
    pub async fn new(ws: reqwest::Upgraded) -> Result<EngineConnection> {
        let ws_stream = tokio_tungstenite::WebSocketStream::from_raw_socket(
            ws,
            tokio_tungstenite::tungstenite::protocol::Role::Client,
-            None,
+            Some(tokio_tungstenite::tungstenite::protocol::WebSocketConfig {
+                write_buffer_size: 1024 * 128,
+                max_write_buffer_size: 1024 * 256,
+                ..Default::default()
+            }),
        )
        .await;

        let (tcp_write, tcp_read) = ws_stream.split();
+        let (engine_req_tx, engine_req_rx) = mpsc::channel(10);
+        tokio::task::spawn(Self::start_write_actor(tcp_write, engine_req_rx));

        let mut tcp_read = TcpRead { stream: tcp_read };

@ -80,42 +123,34 @@ impl EngineConnection {
        });

        Ok(EngineConnection {
-            tcp_write,
-            tcp_read_handle,
+            engine_req_tx,
+            tcp_read_handle: Arc::new(TcpReadHandle {
+                handle: Arc::new(tcp_read_handle),
+            }),
            responses,
        })
    }
-
-    pub async fn tcp_send(&mut self, msg: WebSocketRequest) -> Result<()> {
-        let msg = serde_json::to_string(&msg)?;
-        self.tcp_write.send(WsMsg::Text(msg)).await?;
-
-        Ok(())
-    }
 }

 #[async_trait::async_trait(?Send)]
 impl EngineManager for EngineConnection {
-    /// Send a modeling command.
-    /// Do not wait for the response message.
-    fn send_modeling_cmd(
-        &mut self,
-        id: uuid::Uuid,
-        source_range: crate::executor::SourceRange,
-        cmd: kittycad::types::ModelingCmd,
-    ) -> Result<(), KclError> {
-        futures::executor::block_on(self.send_modeling_cmd_get_response(id, source_range, cmd))?;
-        Ok(())
-    }
-
-    /// Send a modeling command and wait for the response message.
-    async fn send_modeling_cmd_get_response(
-        &mut self,
+    async fn send_modeling_cmd(
+        &self,
        id: uuid::Uuid,
        source_range: crate::executor::SourceRange,
        cmd: kittycad::types::ModelingCmd,
    ) -> Result<OkWebSocketResponseData, KclError> {
-        self.tcp_send(WebSocketRequest::ModelingCmdReq { cmd, cmd_id: id })
+        let (tx, rx) = oneshot::channel();
+
+        // Send the request to the engine, via the actor.
+        self.engine_req_tx
+            .send(ToEngineReq {
+                req: WebSocketRequest::ModelingCmdReq {
+                    cmd: cmd.clone(),
+                    cmd_id: id,
+                },
+                request_sent: tx,
+            })
            .await
            .map_err(|e| {
                KclError::Engine(KclErrorDetails {
@ -124,18 +159,40 @@ impl EngineManager for EngineConnection {
                })
            })?;

+        // Wait for the request to be sent.
+        rx.await
+            .map_err(|e| {
+                KclError::Engine(KclErrorDetails {
+                    message: format!("could not send request to the engine actor: {e}"),
+                    source_ranges: vec![source_range],
+                })
+            })?
+            .map_err(|e| {
+                KclError::Engine(KclErrorDetails {
+                    message: format!("could not send request to the engine: {e}"),
+                    source_ranges: vec![source_range],
+                })
+            })?;
+
        // Wait for the response.
-        loop {
-            if let Some(resp) = self.responses.get(&id) {
-                if let Some(data) = &resp.resp {
-                    return Ok(data.clone());
+        let current_time = std::time::Instant::now();
+        while current_time.elapsed().as_secs() < 60 {
+            // We pop off the responses to cleanup our mappings.
+            if let Some((_, resp)) = self.responses.remove(&id) {
+                return if let Some(data) = &resp.resp {
+                    Ok(data.clone())
                } else {
-                    return Err(KclError::Engine(KclErrorDetails {
+                    Err(KclError::Engine(KclErrorDetails {
                        message: format!("Modeling command failed: {:?}", resp.errors),
                        source_ranges: vec![source_range],
-                    }));
-                }
+                    }))
+                };
            }
        }
+
+        Err(KclError::Engine(KclErrorDetails {
+            message: format!("Modeling command timed out `{}`: {:?}", id, cmd),
+            source_ranges: vec![source_range],
+        }))
    }
 }
--- a/src/wasm-lib/kcl/src/engine/conn_mock.rs
+++ b/src/wasm-lib/kcl/src/engine/conn_mock.rs
@ -6,7 +6,7 @@ use kittycad::types::OkWebSocketResponseData;

 use crate::errors::KclError;

-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct EngineConnection {}

 impl EngineConnection {
@ -17,21 +17,14 @@ impl EngineConnection {

 #[async_trait::async_trait(?Send)]
 impl crate::engine::EngineManager for EngineConnection {
-    fn send_modeling_cmd(
-        &mut self,
-        _id: uuid::Uuid,
-        _source_range: crate::executor::SourceRange,
-        _cmd: kittycad::types::ModelingCmd,
-    ) -> Result<(), KclError> {
-        Ok(())
-    }
-
-    async fn send_modeling_cmd_get_response(
-        &mut self,
+    async fn send_modeling_cmd(
+        &self,
        _id: uuid::Uuid,
        _source_range: crate::executor::SourceRange,
        _cmd: kittycad::types::ModelingCmd,
    ) -> Result<OkWebSocketResponseData, KclError> {
-        todo!()
+        Ok(OkWebSocketResponseData::Modeling {
+            modeling_response: kittycad::types::OkModelingCmdResponse::Empty {},
+        })
    }
 }
--- a/src/wasm-lib/kcl/src/engine/conn_wasm.rs
+++ b/src/wasm-lib/kcl/src/engine/conn_wasm.rs
@ -1,5 +1,6 @@
 //! Functions for setting up our WebSocket and WebRTC connections for communications with the
 //! engine.
+use std::sync::Arc;

 use anyhow::Result;
 use kittycad::types::WebSocketRequest;
@ -23,44 +24,21 @@ extern "C" {

 #[derive(Debug, Clone)]
 pub struct EngineConnection {
-    manager: EngineCommandManager,
+    manager: Arc<EngineCommandManager>,
 }

 impl EngineConnection {
    pub async fn new(manager: EngineCommandManager) -> Result<EngineConnection, JsValue> {
-        Ok(EngineConnection { manager })
+        Ok(EngineConnection {
+            manager: Arc::new(manager),
+        })
    }
 }

 #[async_trait::async_trait(?Send)]
 impl crate::engine::EngineManager for EngineConnection {
-    fn send_modeling_cmd(
-        &mut self,
-        id: uuid::Uuid,
-        source_range: crate::executor::SourceRange,
-        cmd: kittycad::types::ModelingCmd,
-    ) -> Result<(), KclError> {
-        let source_range_str = serde_json::to_string(&source_range).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: format!("Failed to serialize source range: {:?}", e),
-                source_ranges: vec![source_range],
-            })
-        })?;
-        let ws_msg = WebSocketRequest::ModelingCmdReq { cmd, cmd_id: id };
-        let cmd_str = serde_json::to_string(&ws_msg).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: format!("Failed to serialize modeling command: {:?}", e),
-                source_ranges: vec![source_range],
-            })
-        })?;
-        let _ = self
-            .manager
-            .sendModelingCommandFromWasm(id.to_string(), source_range_str, cmd_str);
-        Ok(())
-    }
-
-    async fn send_modeling_cmd_get_response(
-        &mut self,
+    async fn send_modeling_cmd(
+        &self,
        id: uuid::Uuid,
        source_range: crate::executor::SourceRange,
        cmd: kittycad::types::ModelingCmd,
--- a/src/wasm-lib/kcl/src/engine/mod.rs
+++ b/src/wasm-lib/kcl/src/engine/mod.rs
@ -32,19 +32,10 @@ use anyhow::Result;
 pub use conn_mock::EngineConnection;

 #[async_trait::async_trait(?Send)]
-pub trait EngineManager {
-    /// Send a modeling command.
-    /// Do not wait for the response message.
-    fn send_modeling_cmd(
-        &mut self,
-        id: uuid::Uuid,
-        source_range: crate::executor::SourceRange,
-        cmd: kittycad::types::ModelingCmd,
-    ) -> Result<(), crate::errors::KclError>;
-
+pub trait EngineManager: Clone {
    /// Send a modeling command and wait for the response message.
-    async fn send_modeling_cmd_get_response(
-        &mut self,
+    async fn send_modeling_cmd(
+        &self,
        id: uuid::Uuid,
        source_range: crate::executor::SourceRange,
        cmd: kittycad::types::ModelingCmd,
--- a/src/wasm-lib/kcl/src/executor.rs
+++ b/src/wasm-lib/kcl/src/executor.rs
@ -104,7 +104,7 @@ pub enum MemoryItem {
    SketchGroup(Box<SketchGroup>),
    ExtrudeGroup(Box<ExtrudeGroup>),
    #[ts(skip)]
-    ExtrudeTransform(ExtrudeTransform),
+    ExtrudeTransform(Box<ExtrudeTransform>),
    #[ts(skip)]
    Function {
        #[serde(skip)]
@ -134,13 +134,28 @@ pub struct ExtrudeTransform {
    pub meta: Vec<Metadata>,
 }

-pub type MemoryFunction = fn(
-    s: &[MemoryItem],
-    memory: &ProgramMemory,
-    expression: &FunctionExpression,
-    metadata: &[Metadata],
-    engine: &mut EngineConnection,
-) -> Result<Option<ProgramReturn>, KclError>;
+pub type MemoryFunction =
+    fn(
+        s: Vec<MemoryItem>,
+        memory: ProgramMemory,
+        expression: Box<FunctionExpression>,
+        metadata: Vec<Metadata>,
+        engine: EngineConnection,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Option<ProgramReturn>, KclError>>>>;
+
+fn force_memory_function<
+    F: Fn(
+        Vec<MemoryItem>,
+        ProgramMemory,
+        Box<FunctionExpression>,
+        Vec<Metadata>,
+        EngineConnection,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Option<ProgramReturn>, KclError>>>>,
+>(
+    f: F,
+) -> F {
+    f
+}

 impl From<MemoryItem> for Vec<SourceRange> {
    fn from(item: MemoryItem) -> Self {
@ -168,24 +183,24 @@ impl MemoryItem {
        }
    }

-    pub fn call_fn(
+    pub async fn call_fn(
        &self,
-        args: &[MemoryItem],
-        memory: &ProgramMemory,
-        engine: &mut EngineConnection,
+        args: Vec<MemoryItem>,
+        memory: ProgramMemory,
+        engine: EngineConnection,
    ) -> Result<Option<ProgramReturn>, KclError> {
-        if let MemoryItem::Function { func, expression, meta } = self {
+        if let MemoryItem::Function { func, expression, meta } = &self {
            if let Some(func) = func {
-                func(args, memory, expression, meta, engine)
+                func(args, memory, expression.clone(), meta.clone(), engine).await
            } else {
                Err(KclError::Semantic(KclErrorDetails {
-                    message: format!("Not a function: {:?}", self),
+                    message: format!("Not a function: {:?}", expression),
                    source_ranges: vec![],
                }))
            }
        } else {
            Err(KclError::Semantic(KclErrorDetails {
-                message: format!("not a function: {:?}", self),
+                message: "not a in memory function".to_string(),
                source_ranges: vec![],
            }))
        }
@ -579,11 +594,11 @@ impl Default for PipeInfo {
 }

 /// Execute a AST's program.
-pub fn execute(
+pub async fn execute(
    program: crate::ast::types::Program,
    memory: &mut ProgramMemory,
    options: BodyType,
-    engine: &mut EngineConnection,
+    engine: &EngineConnection,
 ) -> Result<ProgramMemory, KclError> {
    let mut pipe_info = PipeInfo::default();

@ -602,7 +617,23 @@ pub fn execute(
                                args.push(memory_item.clone());
                            }
                            Value::CallExpression(call_expr) => {
-                                let result = call_expr.execute(memory, &mut pipe_info, engine)?;
+                                let result = call_expr.execute(memory, &mut pipe_info, engine).await?;
+                                args.push(result);
+                            }
+                            Value::BinaryExpression(binary_expression) => {
+                                let result = binary_expression.get_result(memory, &mut pipe_info, engine).await?;
+                                args.push(result);
+                            }
+                            Value::UnaryExpression(unary_expression) => {
+                                let result = unary_expression.get_result(memory, &mut pipe_info, engine).await?;
+                                args.push(result);
+                            }
+                            Value::ObjectExpression(object_expression) => {
+                                let result = object_expression.execute(memory, &mut pipe_info, engine).await?;
+                                args.push(result);
+                            }
+                            Value::ArrayExpression(array_expression) => {
+                                let result = array_expression.execute(memory, &mut pipe_info, engine).await?;
                                args.push(result);
                            }
                            // We do nothing for the rest.
@ -620,7 +651,7 @@ pub fn execute(

                        memory.return_ = Some(ProgramReturn::Arguments(call_expr.arguments.clone()));
                    } else if let Some(func) = memory.clone().root.get(&fn_name) {
-                        let result = func.call_fn(&args, memory, engine)?;
+                        let result = func.call_fn(args.clone(), memory.clone(), engine.clone()).await?;

                        memory.return_ = result;
                    } else {
@ -646,22 +677,27 @@ pub fn execute(
                            memory.add(&var_name, value.clone(), source_range)?;
                        }
                        Value::BinaryExpression(binary_expression) => {
-                            let result = binary_expression.get_result(memory, &mut pipe_info, engine)?;
+                            let result = binary_expression.get_result(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::FunctionExpression(function_expression) => {
-                            memory.add(
-                                &var_name,
-                                MemoryItem::Function{
-                                    expression: function_expression.clone(),
-                                    meta: vec![metadata],
-                                    func: Some(|args: &[MemoryItem], memory: &ProgramMemory, function_expression: &FunctionExpression, _metadata: &[Metadata], engine: &mut EngineConnection| -> Result<Option<ProgramReturn>, KclError> {
+                            let mem_func = force_memory_function(
+                                |args: Vec<MemoryItem>,
+                                 memory: ProgramMemory,
+                                 function_expression: Box<FunctionExpression>,
+                                 _metadata: Vec<Metadata>,
+                                 engine: EngineConnection| {
+                                    Box::pin(async move {
                                        let mut fn_memory = memory.clone();

                                        if args.len() != function_expression.params.len() {
                                            return Err(KclError::Semantic(KclErrorDetails {
-                                                message: format!("Expected {} arguments, got {}", function_expression.params.len(), args.len()),
-                                                source_ranges: vec![function_expression.into()],
+                                                message: format!(
+                                                    "Expected {} arguments, got {}",
+                                                    function_expression.params.len(),
+                                                    args.len(),
+                                                ),
+                                                source_ranges: vec![(&function_expression).into()],
                                            }));
                                        }

@ -674,20 +710,34 @@ pub fn execute(
                                            )?;
                                        }

-                                        let result = execute(function_expression.body.clone(), &mut fn_memory, BodyType::Block, engine)?;
+                                        let result = execute(
+                                            function_expression.body.clone(),
+                                            &mut fn_memory,
+                                            BodyType::Block,
+                                            &engine,
+                                        )
+                                        .await?;

                                        Ok(result.return_)
                                    })
                                },
+                            );
+                            memory.add(
+                                &var_name,
+                                MemoryItem::Function {
+                                    expression: function_expression.clone(),
+                                    meta: vec![metadata],
+                                    func: Some(mem_func),
+                                },
                                source_range,
                            )?;
                        }
                        Value::CallExpression(call_expression) => {
-                            let result = call_expression.execute(memory, &mut pipe_info, engine)?;
+                            let result = call_expression.execute(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::PipeExpression(pipe_expression) => {
-                            let result = pipe_expression.get_result(memory, &mut pipe_info, engine)?;
+                            let result = pipe_expression.get_result(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::PipeSubstitution(pipe_substitution) => {
@ -700,11 +750,11 @@ pub fn execute(
                            }));
                        }
                        Value::ArrayExpression(array_expression) => {
-                            let result = array_expression.execute(memory, &mut pipe_info, engine)?;
+                            let result = array_expression.execute(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::ObjectExpression(object_expression) => {
-                            let result = object_expression.execute(memory, &mut pipe_info, engine)?;
+                            let result = object_expression.execute(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::MemberExpression(member_expression) => {
@ -712,7 +762,7 @@ pub fn execute(
                            memory.add(&var_name, result, source_range)?;
                        }
                        Value::UnaryExpression(unary_expression) => {
-                            let result = unary_expression.get_result(memory, &mut pipe_info, engine)?;
+                            let result = unary_expression.get_result(memory, &mut pipe_info, engine).await?;
                            memory.add(&var_name, result, source_range)?;
                        }
                    }
@ -720,11 +770,11 @@ pub fn execute(
            }
            BodyItem::ReturnStatement(return_statement) => match &return_statement.argument {
                Value::BinaryExpression(bin_expr) => {
-                    let result = bin_expr.get_result(memory, &mut pipe_info, engine)?;
+                    let result = bin_expr.get_result(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::UnaryExpression(unary_expr) => {
-                    let result = unary_expr.get_result(memory, &mut pipe_info, engine)?;
+                    let result = unary_expr.get_result(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::Identifier(identifier) => {
@ -735,15 +785,15 @@ pub fn execute(
                    memory.return_ = Some(ProgramReturn::Value(literal.into()));
                }
                Value::ArrayExpression(array_expr) => {
-                    let result = array_expr.execute(memory, &mut pipe_info, engine)?;
+                    let result = array_expr.execute(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::ObjectExpression(obj_expr) => {
-                    let result = obj_expr.execute(memory, &mut pipe_info, engine)?;
+                    let result = obj_expr.execute(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::CallExpression(call_expr) => {
-                    let result = call_expr.execute(memory, &mut pipe_info, engine)?;
+                    let result = call_expr.execute(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::MemberExpression(member_expr) => {
@ -751,7 +801,7 @@ pub fn execute(
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::PipeExpression(pipe_expr) => {
-                    let result = pipe_expr.get_result(memory, &mut pipe_info, engine)?;
+                    let result = pipe_expr.get_result(memory, &mut pipe_info, engine).await?;
                    memory.return_ = Some(ProgramReturn::Value(result));
                }
                Value::PipeSubstitution(_) => {}
@ -770,12 +820,12 @@ mod tests {
    use super::*;

    pub async fn parse_execute(code: &str) -> Result<ProgramMemory> {
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = crate::parser::Parser::new(tokens);
        let program = parser.ast()?;
        let mut mem: ProgramMemory = Default::default();
-        let mut engine = EngineConnection::new().await?;
-        let memory = execute(program, &mut mem, BodyType::Root, &mut engine)?;
+        let engine = EngineConnection::new().await?;
+        let memory = execute(program, &mut mem, BodyType::Root, &engine).await?;

        Ok(memory)
    }
--- a/src/wasm-lib/kcl/src/lib.rs
+++ b/src/wasm-lib/kcl/src/lib.rs
@ -9,4 +9,4 @@ pub mod math_parser;
 pub mod parser;
 pub mod server;
 pub mod std;
-pub mod tokeniser;
+pub mod token;
--- a/src/wasm-lib/kcl/src/math_parser.rs
+++ b/src/wasm-lib/kcl/src/math_parser.rs
@ -10,8 +10,8 @@ use crate::{
    },
    errors::{KclError, KclErrorDetails},
    executor::SourceRange,
-    parser::{is_not_code_token, Parser},
-    tokeniser::{Token, TokenType},
+    parser::Parser,
+    token::{Token, TokenType},
 };

 #[derive(Debug, PartialEq, Eq, Deserialize, Serialize, Clone, ts_rs::TS)]
@ -334,7 +334,7 @@ impl ReversePolishNotation {
            return rpn.parse();
        }

-        if is_not_code_token(current_token) {
+        if !current_token.is_code_token() {
            let rpn = ReversePolishNotation::new(&self.parser.tokens[1..], &self.previous_postfix, &self.operators);
            return rpn.parse();
        }
@ -704,7 +704,7 @@ mod test {

    #[test]
    fn test_parse_expression() {
-        let tokens = crate::tokeniser::lexer("1 + 2");
+        let tokens = crate::token::lexer("1 + 2");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -731,7 +731,7 @@ mod test {

    #[test]
    fn test_parse_expression_add_no_spaces() {
-        let tokens = crate::tokeniser::lexer("1+2");
+        let tokens = crate::token::lexer("1+2");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -758,7 +758,7 @@ mod test {

    #[test]
    fn test_parse_expression_sub_no_spaces() {
-        let tokens = crate::tokeniser::lexer("1 -2");
+        let tokens = crate::token::lexer("1 -2");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -785,7 +785,7 @@ mod test {

    #[test]
    fn test_parse_expression_plus_followed_by_star() {
-        let tokens = crate::tokeniser::lexer("1 + 2 * 3");
+        let tokens = crate::token::lexer("1 + 2 * 3");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -823,7 +823,7 @@ mod test {

    #[test]
    fn test_parse_expression_with_parentheses() {
-        let tokens = crate::tokeniser::lexer("1 * ( 2 + 3 )");
+        let tokens = crate::token::lexer("1 * ( 2 + 3 )");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -861,7 +861,7 @@ mod test {

    #[test]
    fn test_parse_expression_parens_in_middle() {
-        let tokens = crate::tokeniser::lexer("1 * ( 2 + 3 ) / 4");
+        let tokens = crate::token::lexer("1 * ( 2 + 3 ) / 4");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -910,7 +910,7 @@ mod test {

    #[test]
    fn test_parse_expression_parans_and_predence() {
-        let tokens = crate::tokeniser::lexer("1 + ( 2 + 3 ) / 4");
+        let tokens = crate::token::lexer("1 + ( 2 + 3 ) / 4");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -958,7 +958,7 @@ mod test {
    }
    #[test]
    fn test_parse_expression_nested() {
-        let tokens = crate::tokeniser::lexer("1 * (( 2 + 3 ) / 4 + 5 )");
+        let tokens = crate::token::lexer("1 * (( 2 + 3 ) / 4 + 5 )");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -1017,7 +1017,7 @@ mod test {
    }
    #[test]
    fn test_parse_expression_redundant_braces() {
-        let tokens = crate::tokeniser::lexer("1 * ((( 2 + 3 )))");
+        let tokens = crate::token::lexer("1 * ((( 2 + 3 )))");
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -1055,7 +1055,7 @@ mod test {

    #[test]
    fn test_reverse_polish_notation_simple() {
-        let parser = ReversePolishNotation::new(&crate::tokeniser::lexer("1 + 2"), &[], &[]);
+        let parser = ReversePolishNotation::new(&crate::token::lexer("1 + 2"), &[], &[]);
        let result = parser.parse().unwrap();
        assert_eq!(
            result,
@ -1084,7 +1084,7 @@ mod test {

    #[test]
    fn test_reverse_polish_notation_complex() {
-        let parser = ReversePolishNotation::new(&crate::tokeniser::lexer("1 + 2 * 3"), &[], &[]);
+        let parser = ReversePolishNotation::new(&crate::token::lexer("1 + 2 * 3"), &[], &[]);
        let result = parser.parse().unwrap();
        assert_eq!(
            result,
@ -1125,7 +1125,7 @@ mod test {

    #[test]
    fn test_reverse_polish_notation_complex_with_parentheses() {
-        let parser = ReversePolishNotation::new(&crate::tokeniser::lexer("1 * ( 2 + 3 )"), &[], &[]);
+        let parser = ReversePolishNotation::new(&crate::token::lexer("1 * ( 2 + 3 )"), &[], &[]);
        let result = parser.parse().unwrap();
        assert_eq!(
            result,
@ -1179,7 +1179,7 @@ mod test {
    #[test]
    fn test_parse_expression_redundant_braces_around_literal() {
        let code = "2 + (((3)))";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse().unwrap();
        assert_eq!(
@ -1274,7 +1274,7 @@ mod test {
    #[test]
    fn test_parse_expression_braces_around_lots_of_math() {
        let code = "(distance * p * FOS * 6 / (sigmaAllow * width))";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse();
        assert!(result.is_ok());
@ -1283,7 +1283,7 @@ mod test {
    #[test]
    fn test_parse_expression_braces_around_internals_lots_of_math() {
        let code = "distance * p * FOS * 6 / (sigmaAllow * width)";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let mut parser = MathParser::new(&tokens);
        let result = parser.parse();
        assert!(result.is_ok());
--- a/src/wasm-lib/kcl/src/parser.rs
+++ b/src/wasm-lib/kcl/src/parser.rs
@ -10,7 +10,7 @@ use crate::{
    },
    errors::{KclError, KclErrorDetails},
    math_parser::MathParser,
-    tokeniser::{Token, TokenType},
+    token::{Token, TokenType},
 };

 pub const PIPE_SUBSTITUTION_OPERATOR: &str = "%";
@ -249,7 +249,7 @@ impl Parser {
        }

        let current_token = self.get_token(index)?;
-        if is_not_code_token(current_token) {
+        if !current_token.is_code_token() {
            return self.find_end_of_non_code_node(index + 1);
        }

@ -262,7 +262,7 @@ impl Parser {
        }

        let current_token = self.get_token(index)?;
-        if is_not_code_token(current_token) {
+        if !current_token.is_code_token() {
            return self.find_start_of_non_code_node(index - 1);
        }

@ -365,7 +365,7 @@ impl Parser {
            });
        };

-        if is_not_code_token(token) {
+        if !token.is_code_token() {
            let non_code_node = self.make_non_code_node(new_index)?;
            let new_new_index = non_code_node.1 + 1;
            let bonus_non_code_node = non_code_node.0;
@ -1283,7 +1283,11 @@ impl Parser {
        let end_token = self.get_token(pipe_body_result.last_index)?;
        Ok(PipeExpressionResult {
            expression: PipeExpression {
-                start: current_token.start,
+                start: pipe_body_result
+                    .body
+                    .first()
+                    .map(|v| v.start())
+                    .unwrap_or(current_token.start),
                end: end_token.end,
                body: pipe_body_result.body,
                non_code_meta: pipe_body_result.non_code_meta,
@ -1623,7 +1627,7 @@ impl Parser {
            });
        }

-        if is_not_code_token(token) {
+        if !token.is_code_token() {
            let next_token = self.next_meaningful_token(token_index, Some(0))?;
            if let Some(node) = &next_token.non_code_node {
                if previous_body.is_empty() {
@ -1788,12 +1792,6 @@ impl Parser {
    }
 }

-pub fn is_not_code_token(token: &Token) -> bool {
-    token.token_type == TokenType::Whitespace
-        || token.token_type == TokenType::LineComment
-        || token.token_type == TokenType::BlockComment
-}
-
 #[cfg(test)]
 mod tests {
    use pretty_assertions::assert_eq;
@ -1803,7 +1801,7 @@ mod tests {

    #[test]
    fn test_make_identifier() {
-        let tokens = crate::tokeniser::lexer("a");
+        let tokens = crate::token::lexer("a");
        let parser = Parser::new(tokens);
        let identifier = parser.make_identifier(0).unwrap();
        assert_eq!(
@ -1818,7 +1816,7 @@ mod tests {

    #[test]
    fn test_make_identifier_with_const_myvar_equals_5_and_index_2() {
-        let tokens = crate::tokeniser::lexer("const myVar = 5");
+        let tokens = crate::token::lexer("const myVar = 5");
        let parser = Parser::new(tokens);
        let identifier = parser.make_identifier(2).unwrap();
        assert_eq!(
@ -1833,7 +1831,7 @@ mod tests {

    #[test]
    fn test_make_identifier_multiline() {
-        let tokens = crate::tokeniser::lexer("const myVar = 5\nconst newVar = myVar + 1");
+        let tokens = crate::token::lexer("const myVar = 5\nconst newVar = myVar + 1");
        let parser = Parser::new(tokens);
        let identifier = parser.make_identifier(2).unwrap();
        assert_eq!(
@ -1857,7 +1855,7 @@ mod tests {

    #[test]
    fn test_make_identifier_call_expression() {
-        let tokens = crate::tokeniser::lexer("log(5, \"hello\", aIdentifier)");
+        let tokens = crate::token::lexer("log(5, \"hello\", aIdentifier)");
        let parser = Parser::new(tokens);
        let identifier = parser.make_identifier(0).unwrap();
        assert_eq!(
@ -1880,7 +1878,7 @@ mod tests {
    }
    #[test]
    fn test_make_non_code_node() {
-        let tokens = crate::tokeniser::lexer("log(5, \"hello\", aIdentifier)");
+        let tokens = crate::token::lexer("log(5, \"hello\", aIdentifier)");
        let parser = Parser::new(tokens);
        let index = 4;
        let expected_output = (None, 4);
@ -1889,7 +1887,7 @@ mod tests {
        let index = 7;
        let expected_output = (None, 7);
        assert_eq!(parser.make_non_code_node(index).unwrap(), expected_output);
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"
 const yo = { a: { b: { c: '123' } } }
 // this is a comment
@ -1920,7 +1918,7 @@ const key = 'c'"#,
            31,
        );
        assert_eq!(parser.make_non_code_node(index).unwrap(), expected_output);
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const mySketch = startSketchAt([0,0])
  |> lineTo({ to: [0, 1], tag: 'myPath' }, %)
  |> lineTo([1, 1], %) /* this is
@ -1946,7 +1944,7 @@ const key = 'c'"#,

    #[test]
    fn test_collect_object_keys() {
-        let tokens = crate::tokeniser::lexer("const prop = yo.one[\"two\"]");
+        let tokens = crate::token::lexer("const prop = yo.one[\"two\"]");
        let parser = Parser::new(tokens);
        let keys_info = parser.collect_object_keys(6, None, false).unwrap();
        assert_eq!(keys_info.len(), 2);
@ -1966,7 +1964,7 @@ const key = 'c'"#,

    #[test]
    fn test_make_literal_call_expression() {
-        let tokens = crate::tokeniser::lexer("log(5, \"hello\", aIdentifier)");
+        let tokens = crate::token::lexer("log(5, \"hello\", aIdentifier)");
        let parser = Parser::new(tokens);
        let literal = parser.make_literal(2).unwrap();
        assert_eq!(
@ -1990,74 +1988,88 @@ const key = 'c'"#,
        );
    }

+    #[test]
+    fn test_is_code_token() {
+        let tokens = [
+            Token {
+                token_type: TokenType::Word,
+                start: 0,
+                end: 3,
+                value: "log".to_string(),
+            },
+            Token {
+                token_type: TokenType::Brace,
+                start: 3,
+                end: 4,
+                value: "(".to_string(),
+            },
+            Token {
+                token_type: TokenType::Number,
+                start: 4,
+                end: 5,
+                value: "5".to_string(),
+            },
+            Token {
+                token_type: TokenType::Comma,
+                start: 5,
+                end: 6,
+                value: ",".to_string(),
+            },
+            Token {
+                token_type: TokenType::String,
+                start: 7,
+                end: 14,
+                value: "\"hello\"".to_string(),
+            },
+            Token {
+                token_type: TokenType::Word,
+                start: 16,
+                end: 27,
+                value: "aIdentifier".to_string(),
+            },
+            Token {
+                token_type: TokenType::Brace,
+                start: 27,
+                end: 28,
+                value: ")".to_string(),
+            },
+        ];
+        for (i, token) in tokens.iter().enumerate() {
+            assert!(token.is_code_token(), "failed test {i}: {token:?}")
+        }
+    }
+
    #[test]
    fn test_is_not_code_token() {
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Word,
-            start: 0,
-            end: 3,
-            value: "log".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Brace,
-            start: 3,
-            end: 4,
-            value: "(".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Number,
-            start: 4,
-            end: 5,
-            value: "5".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Comma,
-            start: 5,
-            end: 6,
-            value: ",".to_string(),
-        }));
-        assert!(is_not_code_token(&Token {
-            token_type: TokenType::Whitespace,
-            start: 6,
-            end: 7,
-            value: " ".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::String,
-            start: 7,
-            end: 14,
-            value: "\"hello\"".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Word,
-            start: 16,
-            end: 27,
-            value: "aIdentifier".to_string(),
-        }));
-        assert!(!is_not_code_token(&Token {
-            token_type: TokenType::Brace,
-            start: 27,
-            end: 28,
-            value: ")".to_string(),
-        }));
-        assert!(is_not_code_token(&Token {
-            token_type: TokenType::BlockComment,
-            start: 28,
-            end: 30,
-            value: "/* abte */".to_string(),
-        }));
-        assert!(is_not_code_token(&Token {
-            token_type: TokenType::LineComment,
-            start: 30,
-            end: 33,
-            value: "// yoyo a line".to_string(),
-        }));
+        let tokens = [
+            Token {
+                token_type: TokenType::Whitespace,
+                start: 6,
+                end: 7,
+                value: " ".to_string(),
+            },
+            Token {
+                token_type: TokenType::BlockComment,
+                start: 28,
+                end: 30,
+                value: "/* abte */".to_string(),
+            },
+            Token {
+                token_type: TokenType::LineComment,
+                start: 30,
+                end: 33,
+                value: "// yoyo a line".to_string(),
+            },
+        ];
+        for (i, token) in tokens.iter().enumerate() {
+            assert!(!token.is_code_token(), "failed test {i}: {token:?}")
+        }
    }

    #[test]
    fn test_next_meaningful_token() {
        let _offset = 1;
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const mySketch = startSketchAt([0,0])
  |> lineTo({ to: [0, 1], tag: 'myPath' }, %)
  |> lineTo([1, 1], %) /* this is
@ -2443,7 +2455,7 @@ const key = 'c'"#,

    #[test]
    fn test_find_closing_brace() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const mySketch = startSketchAt([0,0])
 |> lineTo({ to: [0, 1], tag: 'myPath' }, %)
 |> lineTo([1, 1], %) /* this is
@ -2460,16 +2472,16 @@ const key = 'c'"#,
        assert_eq!(parser.find_closing_brace(90, 0, "").unwrap(), 92);

        let basic = "( hey )";
-        let parser = Parser::new(crate::tokeniser::lexer(basic));
+        let parser = Parser::new(crate::token::lexer(basic));
        assert_eq!(parser.find_closing_brace(0, 0, "").unwrap(), 4);

        let handles_non_zero_index = "(indexForBracketToRightOfThisIsTwo(shouldBeFour)AndNotThisSix)";
-        let parser = Parser::new(crate::tokeniser::lexer(handles_non_zero_index));
+        let parser = Parser::new(crate::token::lexer(handles_non_zero_index));
        assert_eq!(parser.find_closing_brace(2, 0, "").unwrap(), 4);
        assert_eq!(parser.find_closing_brace(0, 0, "").unwrap(), 6);

        let handles_nested = "{a{b{c(}d]}eathou athoeu tah u} thatOneToTheLeftIsLast }";
-        let parser = Parser::new(crate::tokeniser::lexer(handles_nested));
+        let parser = Parser::new(crate::token::lexer(handles_nested));
        assert_eq!(parser.find_closing_brace(0, 0, "").unwrap(), 18);

        // TODO expect error when not started on a brace
@ -2477,7 +2489,7 @@ const key = 'c'"#,

    #[test]
    fn test_is_call_expression() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const mySketch = startSketchAt([0,0])
 |> lineTo({ to: [0, 1], tag: 'myPath' }, %)
 |> lineTo([1, 1], %) /* this is
@ -2498,7 +2510,7 @@ const key = 'c'"#,

    #[test]
    fn test_find_next_declaration_keyword() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const mySketch = startSketchAt([0,0])
 |> lineTo({ to: [0, 1], tag: 'myPath' }, %)
 |> lineTo([1, 1], %) /* this is
@ -2513,7 +2525,7 @@ const key = 'c'"#,
            TokenReturn { token: None, index: 92 }
        );

-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const myVar = 5
 const newVar = myVar + 1
 "#,
@ -2543,7 +2555,7 @@ const newVar = myVar + 1
  lineTo(2, 3)
 } |> rx(45, %)
 "#;
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens);
        assert_eq!(
            parser.has_pipe_operator(0, None).unwrap(),
@ -2562,7 +2574,7 @@ const newVar = myVar + 1
  lineTo(2, 3)
 } |> rx(45, %) |> rx(45, %)
 "#;
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens);
        assert_eq!(
            parser.has_pipe_operator(0, None).unwrap(),
@ -2584,7 +2596,7 @@ const newVar = myVar + 1
 const yo = myFunc(9()
  |> rx(45, %)
 "#;
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens);
        assert_eq!(
            parser.has_pipe_operator(0, None).unwrap(),
@ -2596,7 +2608,7 @@ const yo = myFunc(9()
        );

        let code = "const myVar2 = 5 + 1 |> myFn(%)";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens);
        assert_eq!(
            parser.has_pipe_operator(1, None).unwrap(),
@ -2618,7 +2630,7 @@ const yo = myFunc(9()
  lineTo(1,1)
 } |> rx(90, %)
 show(mySk1)"#;
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let token_with_my_path_index = tokens.iter().position(|token| token.value == "myPath").unwrap();
        // loop through getting the token and it's index
@ -2658,7 +2670,7 @@ show(mySk1)"#;

    #[test]
    fn test_make_member_expression() {
-        let tokens = crate::tokeniser::lexer("const prop = yo.one[\"two\"]");
+        let tokens = crate::token::lexer("const prop = yo.one[\"two\"]");
        let parser = Parser::new(tokens);
        let member_expression_return = parser.make_member_expression(6).unwrap();
        let member_expression = member_expression_return.expression;
@ -2700,63 +2712,63 @@ show(mySk1)"#;
    #[test]
    fn test_find_end_of_binary_expression() {
        let code = "1 + 2 * 3\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].value, "3");

        let code = "(1 + 25) / 5 - 3\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].value, "3");
        let index_of_5 = code.find('5').unwrap();
        let end_starting_at_the_5 = parser.find_end_of_binary_expression(index_of_5).unwrap();
        assert_eq!(end_starting_at_the_5, end);
-        // whole thing wraped
+        // whole thing wrapped
        let code = "((1 + 2) / 5 - 3)\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].end, code.find("3)").unwrap() + 2);
-        // whole thing wraped but given index after the first brace
+        // whole thing wrapped but given index after the first brace
        let code = "((1 + 2) / 5 - 3)\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(1).unwrap();
        assert_eq!(tokens[end].value, "3");
        // given the index of a small wrapped section i.e. `1 + 2` in ((1 + 2) / 5 - 3)'
        let code = "((1 + 2) / 5 - 3)\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(2).unwrap();
        assert_eq!(tokens[end].value, "2");
        // lots of silly nesting
        let code = "(1 + 2) / (5 - (3))\nconst yo = 5";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].end, code.find("))").unwrap() + 2);
        // with pipe operator at the end
        let code = "(1 + 2) / (5 - (3))\n  |> fn(%)";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].end, code.find("))").unwrap() + 2);
        // with call expression at the start of binary expression
        let code = "yo(2) + 3\n  |> fn(%)";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].value, "3");
        // with call expression at the end of binary expression
        let code = "3 + yo(2)\n  |> fn(%)";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens);
        let _end = parser.find_end_of_binary_expression(0).unwrap();
        // with call expression at the end of binary expression
        let code = "-legX + 2, ";
-        let tokens = crate::tokeniser::lexer(code);
+        let tokens = crate::token::lexer(code);
        let parser = Parser::new(tokens.clone());
        let end = parser.find_end_of_binary_expression(0).unwrap();
        assert_eq!(tokens[end].value, "2");
@ -2765,7 +2777,7 @@ show(mySk1)"#;
    #[test]
    fn test_make_array_expression() {
        // input_index: 6, output_index: 14, output: {"type":"ArrayExpression","start":11,"end":26,"elements":[{"type":"Literal","start":12,"end":15,"value":"1","raw":"\"1\""},{"type":"Literal","start":17,"end":18,"value":2,"raw":"2"},{"type":"Identifier","start":20,"end":25,"name":"three"}]}
-        let tokens = crate::tokeniser::lexer("const yo = [\"1\", 2, three]");
+        let tokens = crate::token::lexer("const yo = [\"1\", 2, three]");
        let parser = Parser::new(tokens);
        let array_expression = parser.make_array_expression(6).unwrap();
        let expression = array_expression.expression;
@ -2804,7 +2816,7 @@ show(mySk1)"#;

    #[test]
    fn test_make_call_expression() {
-        let tokens = crate::tokeniser::lexer("foo(\"a\", a, 3)");
+        let tokens = crate::token::lexer("foo(\"a\", a, 3)");
        let parser = Parser::new(tokens);
        let result = parser.make_call_expression(0).unwrap();
        assert_eq!(result.last_index, 9);
@ -2838,7 +2850,7 @@ show(mySk1)"#;

    #[test]
    fn test_make_variable_declaration() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const yo = startSketch([0, 0])
  |> lineTo([1, myVar], %)
  |> foo(myVar2, %)
@ -2908,7 +2920,7 @@ show(mySk1)"#;

    #[test]
    fn test_make_body() {
-        let tokens = crate::tokeniser::lexer("const myVar = 5");
+        let tokens = crate::token::lexer("const myVar = 5");
        let parser = Parser::new(tokens);
        let body = parser
            .make_body(
@ -2926,7 +2938,7 @@ show(mySk1)"#;
    #[test]
    fn test_abstract_syntax_tree() {
        let code = "5 +6";
-        let parser = Parser::new(crate::tokeniser::lexer(code));
+        let parser = Parser::new(crate::token::lexer(code));
        let result = parser.ast().unwrap();
        let expected_result = Program {
            start: 0,
@ -2964,8 +2976,8 @@ show(mySk1)"#;
    #[test]
    fn test_empty_file() {
        let some_program_string = r#""#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert!(result.err().unwrap().to_string().contains("file is empty"));
@ -2973,7 +2985,7 @@ show(mySk1)"#;

    #[test]
    fn test_parse_half_pipe_small() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            "const secondExtrude = startSketchAt([0,0])
  |",
        );
@ -2985,14 +2997,14 @@ show(mySk1)"#;

    #[test]
    fn test_parse_member_expression_double_nested_braces() {
-        let tokens = crate::tokeniser::lexer(r#"const prop = yo["one"][two]"#);
+        let tokens = crate::token::lexer(r#"const prop = yo["one"][two]"#);
        let parser = Parser::new(tokens);
        parser.ast().unwrap();
    }

    #[test]
    fn test_parse_member_expression_binary_expression_period_number_first() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = 1 - obj.a"#,
        );
@ -3002,7 +3014,7 @@ const height = 1 - obj.a"#,

    #[test]
    fn test_parse_member_expression_binary_expression_brace_number_first() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = 1 - obj["a"]"#,
        );
@ -3012,7 +3024,7 @@ const height = 1 - obj["a"]"#,

    #[test]
    fn test_parse_member_expression_binary_expression_brace_number_second() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = obj["a"] - 1"#,
        );
@ -3022,7 +3034,7 @@ const height = obj["a"] - 1"#,

    #[test]
    fn test_parse_member_expression_binary_expression_in_array_number_first() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = [1 - obj["a"], 0]"#,
        );
@ -3032,7 +3044,7 @@ const height = [1 - obj["a"], 0]"#,

    #[test]
    fn test_parse_member_expression_binary_expression_in_array_number_second() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = [obj["a"] - 1, 0]"#,
        );
@ -3042,7 +3054,7 @@ const height = [obj["a"] - 1, 0]"#,

    #[test]
    fn test_parse_member_expression_binary_expression_in_array_number_second_missing_space() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const obj = { a: 1, b: 2 }
 const height = [obj["a"] -1, 0]"#,
        );
@ -3052,7 +3064,7 @@ const height = [obj["a"] -1, 0]"#,

    #[test]
    fn test_parse_half_pipe() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            "const height = 10

 const firstExtrude = startSketchAt([0,0])
@ -3075,15 +3087,17 @@ const secondExtrude = startSketchAt([0,0])

    #[test]
    fn test_parse_greater_bang() {
-        let tokens = crate::tokeniser::lexer(">!");
+        let tokens = crate::token::lexer(">!");
        let parser = Parser::new(tokens);
-        let result = parser.ast();
-        assert!(result.is_ok());
+        let err = parser.ast().unwrap_err();
+        // TODO: Better errors when program cannot tokenize.
+        // https://github.com/KittyCAD/modeling-app/issues/696
+        assert!(err.to_string().contains("file is empty"));
    }

    #[test]
    fn test_parse_z_percent_parens() {
-        let tokens = crate::tokeniser::lexer("z%)");
+        let tokens = crate::token::lexer("z%)");
        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
@ -3092,15 +3106,17 @@ const secondExtrude = startSketchAt([0,0])

    #[test]
    fn test_parse_parens_unicode() {
-        let tokens = crate::tokeniser::lexer("(ޜ");
+        let tokens = crate::token::lexer("(ޜ");
        let parser = Parser::new(tokens);
        let result = parser.ast();
-        assert!(result.is_ok());
+        // TODO: Better errors when program cannot tokenize.
+        // https://github.com/KittyCAD/modeling-app/issues/696
+        assert!(result.is_err());
    }

    #[test]
    fn test_parse_negative_in_array_binary_expression() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"const leg1 = 5
 const thickness = 0.56

@ -3114,7 +3130,7 @@ const bracket = [-leg2 + thickness, 0]

    #[test]
    fn test_parse_nested_open_brackets() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"
 z(-[["#,
        );
@ -3129,31 +3145,38 @@ z(-[["#,

    #[test]
    fn test_parse_weird_new_line_function() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"z
 (--#"#,
        );
        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
+        // TODO: Better errors when program cannot tokenize.
+        // https://github.com/KittyCAD/modeling-app/issues/696
        assert_eq!(
            result.err().unwrap().to_string(),
-            r#"syntax: KclErrorDetails { source_ranges: [SourceRange([0, 1])], message: "missing a closing brace for the function call" }"#
+            r#"semantic: KclErrorDetails { source_ranges: [], message: "file is empty" }"#
        );
    }

    #[test]
    fn test_parse_weird_lots_of_fancy_brackets() {
-        let tokens = crate::tokeniser::lexer(r#"zz({{{{{{{{)iegAng{{{{{{{##"#);
+        let tokens = crate::token::lexer(r#"zz({{{{{{{{)iegAng{{{{{{{##"#);
        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
-        assert!(result.err().unwrap().to_string().contains("unexpected end"));
+        // TODO: Better errors when program cannot tokenize.
+        // https://github.com/KittyCAD/modeling-app/issues/696
+        assert_eq!(
+            result.err().unwrap().to_string(),
+            r#"semantic: KclErrorDetails { source_ranges: [], message: "file is empty" }"#
+        );
    }

    #[test]
    fn test_parse_weird_close_before_open() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"fn)n
 e
 ["#,
@ -3170,7 +3193,7 @@ e

    #[test]
    fn test_parse_weird_close_before_nada() {
-        let tokens = crate::tokeniser::lexer(r#"fn)n-"#);
+        let tokens = crate::token::lexer(r#"fn)n-"#);
        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
@ -3179,7 +3202,7 @@ e

    #[test]
    fn test_parse_weird_lots_of_slashes() {
-        let tokens = crate::tokeniser::lexer(
+        let tokens = crate::token::lexer(
            r#"J///////////o//+///////////P++++*++++++P///////˟
 ++4"#,
        );
@ -3196,7 +3219,7 @@ e
    #[test]
    fn test_parse_expand_array() {
        let code = "const myArray = [0..10]";
-        let parser = Parser::new(crate::tokeniser::lexer(code));
+        let parser = Parser::new(crate::token::lexer(code));
        let result = parser.ast().unwrap();
        let expected_result = Program {
            start: 0,
@ -3299,8 +3322,8 @@ e
    #[test]
    fn test_error_keyword_in_variable() {
        let some_program_string = r#"const let = "thing""#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3312,8 +3335,8 @@ e
    #[test]
    fn test_error_keyword_in_fn_name() {
        let some_program_string = r#"fn let = () {}"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3325,8 +3348,8 @@ e
    #[test]
    fn test_error_stdlib_in_fn_name() {
        let some_program_string = r#"fn cos = () {}"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3340,8 +3363,8 @@ e
        let some_program_string = r#"fn thing = (let) => {
    return 1
 }"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3355,8 +3378,8 @@ e
        let some_program_string = r#"fn thing = (cos) => {
    return 1
 }"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3373,8 +3396,8 @@ e
        }
        firstPrimeNumber()
        "#;
-        let tokens = crate::tokeniser::lexer(program);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(program);
+        let parser = Parser::new(tokens);
        let _ast = parser.ast().unwrap();
    }

@ -3386,8 +3409,8 @@ e

 thing(false)
 "#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        parser.ast().unwrap();
    }

@ -3403,8 +3426,8 @@ thing(false)
 "#,
                name
            );
-            let tokens = crate::tokeniser::lexer(&some_program_string);
-            let parser = crate::parser::Parser::new(tokens);
+            let tokens = crate::token::lexer(&some_program_string);
+            let parser = Parser::new(tokens);
            let result = parser.ast();
            assert!(result.is_err());
            assert_eq!(
@ -3421,8 +3444,8 @@ thing(false)
    #[test]
    fn test_error_define_var_as_function() {
        let some_program_string = r#"fn thing = "thing""#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
        assert_eq!(
@ -3450,8 +3473,8 @@ const pt2 = b2[0]

 show(b1)
 show(b2)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        parser.ast().unwrap();
    }

@ -3459,18 +3482,36 @@ show(b2)"#;
    fn test_math_with_stdlib() {
        let some_program_string = r#"const d2r = pi() / 2
 let other_thing = 2 * cos(3)"#;
-        let tokens = crate::tokeniser::lexer(some_program_string);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        parser.ast().unwrap();
    }

    #[test]
-    #[ignore] // ignore until more stack fixes
    fn test_parse_pipes_on_pipes() {
        let code = include_str!("../../tests/executor/inputs/pipes_on_pipes.kcl");

-        let tokens = crate::tokeniser::lexer(code);
-        let parser = crate::parser::Parser::new(tokens);
+        let tokens = crate::token::lexer(code);
+        let parser = Parser::new(tokens);
+        parser.ast().unwrap();
+    }
+
+    #[test]
+    fn test_negative_arguments() {
+        let some_program_string = r#"fn box = (p, h, l, w) => {
+ const myBox = startSketchAt(p)
+    |> line([0, l], %)
+    |> line([w, 0], %)
+    |> line([0, -l], %)
+    |> close(%)
+    |> extrude(h, %)
+
+  return myBox
+}
+let myBox = box([0,0], -3, -16, -10)
+show(myBox)"#;
+        let tokens = crate::token::lexer(some_program_string);
+        let parser = Parser::new(tokens);
        parser.ast().unwrap();
    }
 }
--- a/src/wasm-lib/kcl/src/server/mod.rs
+++ b/src/wasm-lib/kcl/src/server/mod.rs
@ -34,7 +34,7 @@ pub struct Backend {
    /// The types of tokens the server supports.
    pub token_types: Vec<SemanticTokenType>,
    /// Token maps.
-    pub token_map: DashMap<String, Vec<crate::tokeniser::Token>>,
+    pub token_map: DashMap<String, Vec<crate::token::Token>>,
    /// AST maps.
    pub ast_map: DashMap<String, crate::ast::types::Program>,
    /// Current code.
@ -56,7 +56,7 @@ impl Backend {
        // Lets update the tokens.
        self.current_code_map
            .insert(params.uri.to_string(), params.text.clone());
-        let tokens = crate::tokeniser::lexer(&params.text);
+        let tokens = crate::token::lexer(&params.text);
        self.token_map.insert(params.uri.to_string(), tokens.clone());

        // Update the semantic tokens map.
@ -69,9 +69,7 @@ impl Backend {
                continue;
            };

-            if token.token_type == crate::tokeniser::TokenType::Word
-                && self.stdlib_completions.contains_key(&token.value)
-            {
+            if token.token_type == crate::token::TokenType::Word && self.stdlib_completions.contains_key(&token.value) {
                // This is a stdlib function.
                token_type = SemanticTokenType::FUNCTION;
            }
@ -549,7 +547,7 @@ impl LanguageServer for Backend {
        // Parse the ast.
        // I don't know if we need to do this again since it should be updated in the context.
        // But I figure better safe than sorry since this will write back out to the file.
-        let tokens = crate::tokeniser::lexer(&current_code);
+        let tokens = crate::token::lexer(&current_code);
        let parser = crate::parser::Parser::new(tokens);
        let Ok(ast) = parser.ast() else {
            return Ok(None);
@ -581,7 +579,7 @@ impl LanguageServer for Backend {
        // Parse the ast.
        // I don't know if we need to do this again since it should be updated in the context.
        // But I figure better safe than sorry since this will write back out to the file.
-        let tokens = crate::tokeniser::lexer(&current_code);
+        let tokens = crate::token::lexer(&current_code);
        let parser = crate::parser::Parser::new(tokens);
        let Ok(mut ast) = parser.ast() else {
            return Ok(None);
--- a/src/wasm-lib/kcl/src/std/extrude.rs
+++ b/src/wasm-lib/kcl/src/std/extrude.rs
@ -11,10 +11,10 @@ use crate::{
 };

 /// Extrudes by a given amount.
-pub fn extrude(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn extrude(args: Args) -> Result<MemoryItem, KclError> {
    let (length, sketch_group) = args.get_number_sketch_group()?;

-    let result = inner_extrude(length, sketch_group, args)?;
+    let result = inner_extrude(length, sketch_group, args).await?;

    Ok(MemoryItem::ExtrudeGroup(result))
 }
@ -23,7 +23,7 @@ pub fn extrude(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "extrude"
 }]
-fn inner_extrude(length: f64, sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<Box<ExtrudeGroup>, KclError> {
+async fn inner_extrude(length: f64, sketch_group: Box<SketchGroup>, args: Args) -> Result<Box<ExtrudeGroup>, KclError> {
    let id = uuid::Uuid::new_v4();

    let cmd = kittycad::types::ModelingCmd::Extrude {
@ -31,7 +31,7 @@ fn inner_extrude(length: f64, sketch_group: Box<SketchGroup>, args: &mut Args) -
        distance: length,
        cap: true,
    };
-    args.send_modeling_cmd(id, cmd)?;
+    args.send_modeling_cmd(id, cmd).await?;

    Ok(Box::new(ExtrudeGroup {
        id,
@ -46,7 +46,7 @@ fn inner_extrude(length: f64, sketch_group: Box<SketchGroup>, args: &mut Args) -
 }

 /// Returns the extrude wall transform.
-pub fn get_extrude_wall_transform(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn get_extrude_wall_transform(args: Args) -> Result<MemoryItem, KclError> {
    let (surface_name, extrude_group) = args.get_path_name_extrude_group()?;
    let result = inner_get_extrude_wall_transform(&surface_name, *extrude_group, args)?;
    Ok(MemoryItem::ExtrudeTransform(result))
@ -59,8 +59,8 @@ pub fn get_extrude_wall_transform(args: &mut Args) -> Result<MemoryItem, KclErro
 fn inner_get_extrude_wall_transform(
    surface_name: &str,
    extrude_group: ExtrudeGroup,
-    args: &mut Args,
-) -> Result<ExtrudeTransform, KclError> {
+    args: Args,
+) -> Result<Box<ExtrudeTransform>, KclError> {
    let surface = extrude_group.get_path_by_name(surface_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
            message: format!(
@ -71,9 +71,9 @@ fn inner_get_extrude_wall_transform(
        })
    })?;

-    Ok(ExtrudeTransform {
+    Ok(Box::new(ExtrudeTransform {
        position: surface.get_position(),
        rotation: surface.get_rotation(),
        meta: extrude_group.meta,
-    })
+    }))
 }
--- a/src/wasm-lib/kcl/src/std/math.rs
+++ b/src/wasm-lib/kcl/src/std/math.rs
@ -11,7 +11,7 @@ use crate::{
 };

 /// Computes the cosine of a number (in radians).
-pub fn cos(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn cos(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_cos(num)?;

@ -27,7 +27,7 @@ fn inner_cos(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the sine of a number (in radians).
-pub fn sin(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn sin(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_sin(num)?;

@ -43,7 +43,7 @@ fn inner_sin(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the tangent of a number (in radians).
-pub fn tan(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn tan(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_tan(num)?;

@ -59,7 +59,7 @@ fn inner_tan(num: f64) -> Result<f64, KclError> {
 }

 /// Return the value of `pi`. Archimedes’ constant (π).
-pub fn pi(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn pi(args: Args) -> Result<MemoryItem, KclError> {
    let result = inner_pi()?;

    args.make_user_val_from_f64(result)
@ -74,7 +74,7 @@ fn inner_pi() -> Result<f64, KclError> {
 }

 /// Computes the square root of a number.
-pub fn sqrt(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn sqrt(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_sqrt(num)?;

@ -90,7 +90,7 @@ fn inner_sqrt(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the absolute value of a number.
-pub fn abs(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn abs(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_abs(num)?;

@ -106,7 +106,7 @@ fn inner_abs(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the largest integer less than or equal to a number.
-pub fn floor(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn floor(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_floor(num)?;

@ -122,7 +122,7 @@ fn inner_floor(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the smallest integer greater than or equal to a number.
-pub fn ceil(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn ceil(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_ceil(num)?;

@ -138,7 +138,7 @@ fn inner_ceil(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the minimum of the given arguments.
-pub fn min(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn min(args: Args) -> Result<MemoryItem, KclError> {
    let nums = args.get_number_array()?;
    let result = inner_min(nums);

@ -161,7 +161,7 @@ fn inner_min(args: Vec<f64>) -> f64 {
 }

 /// Computes the maximum of the given arguments.
-pub fn max(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn max(args: Args) -> Result<MemoryItem, KclError> {
    let nums = args.get_number_array()?;
    let result = inner_max(nums);

@ -184,7 +184,7 @@ fn inner_max(args: Vec<f64>) -> f64 {
 }

 /// Computes the number to a power.
-pub fn pow(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn pow(args: Args) -> Result<MemoryItem, KclError> {
    let nums = args.get_number_array()?;
    if nums.len() > 2 {
        return Err(KclError::Type(KclErrorDetails {
@ -214,7 +214,7 @@ fn inner_pow(num: f64, pow: f64) -> Result<f64, KclError> {
 }

 /// Computes the arccosine of a number (in radians).
-pub fn acos(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn acos(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_acos(num)?;

@ -230,7 +230,7 @@ fn inner_acos(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the arcsine of a number (in radians).
-pub fn asin(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn asin(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_asin(num)?;

@ -246,7 +246,7 @@ fn inner_asin(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the arctangent of a number (in radians).
-pub fn atan(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn atan(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_atan(num)?;

@ -266,7 +266,7 @@ fn inner_atan(num: f64) -> Result<f64, KclError> {
 /// The result might not be correctly rounded owing to implementation
 /// details; `log2()` can produce more accurate results for base 2,
 /// and `log10()` can produce more accurate results for base 10.
-pub fn log(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn log(args: Args) -> Result<MemoryItem, KclError> {
    let nums = args.get_number_array()?;
    if nums.len() > 2 {
        return Err(KclError::Type(KclErrorDetails {
@ -299,7 +299,7 @@ fn inner_log(num: f64, base: f64) -> Result<f64, KclError> {
 }

 /// Computes the base 2 logarithm of the number.
-pub fn log2(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn log2(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_log2(num)?;

@ -315,7 +315,7 @@ fn inner_log2(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the base 10 logarithm of the number.
-pub fn log10(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn log10(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_log10(num)?;

@ -331,7 +331,7 @@ fn inner_log10(num: f64) -> Result<f64, KclError> {
 }

 /// Computes the natural logarithm of the number.
-pub fn ln(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn ln(args: Args) -> Result<MemoryItem, KclError> {
    let num = args.get_number()?;
    let result = inner_ln(num)?;

@ -347,7 +347,7 @@ fn inner_ln(num: f64) -> Result<f64, KclError> {
 }

 /// Return the value of Euler’s number `e`.
-pub fn e(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn e(args: Args) -> Result<MemoryItem, KclError> {
    let result = inner_e()?;

    args.make_user_val_from_f64(result)
@ -362,7 +362,7 @@ fn inner_e() -> Result<f64, KclError> {
 }

 /// Return the value of `tau`. The full circle constant (τ). Equal to 2π.
-pub fn tau(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn tau(args: Args) -> Result<MemoryItem, KclError> {
    let result = inner_tau()?;

    args.make_user_val_from_f64(result)
--- a/src/wasm-lib/kcl/src/std/mod.rs
+++ b/src/wasm-lib/kcl/src/std/mod.rs
@ -10,6 +10,7 @@ use std::collections::HashMap;

 use anyhow::Result;
 use derive_docs::stdlib;
+use kittycad::types::OkWebSocketResponseData;
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
@ -21,7 +22,7 @@ use crate::{
    executor::{ExtrudeGroup, MemoryItem, Metadata, SketchGroup, SourceRange},
 };

-pub type StdFn = fn(&mut Args) -> Result<MemoryItem, KclError>;
+pub type StdFn = fn(Args) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<MemoryItem, KclError>>>>;
 pub type FnMap = HashMap<String, StdFn>;

 pub struct StdLib {
@ -60,6 +61,8 @@ impl StdLib {
            Box::new(crate::std::sketch::StartSketchAt),
            Box::new(crate::std::sketch::Close),
            Box::new(crate::std::sketch::Arc),
+            Box::new(crate::std::sketch::TangentalArc),
+            Box::new(crate::std::sketch::TangentalArcTo),
            Box::new(crate::std::sketch::BezierCurve),
            Box::new(crate::std::math::Cos),
            Box::new(crate::std::math::Sin),
@ -102,15 +105,15 @@ impl Default for StdLib {
    }
 }

-#[derive(Debug)]
-pub struct Args<'a> {
+#[derive(Debug, Clone)]
+pub struct Args {
    pub args: Vec<MemoryItem>,
    pub source_range: SourceRange,
-    engine: &'a mut EngineConnection,
+    engine: EngineConnection,
 }

-impl<'a> Args<'a> {
-    pub fn new(args: Vec<MemoryItem>, source_range: SourceRange, engine: &'a mut EngineConnection) -> Self {
+impl Args {
+    pub fn new(args: Vec<MemoryItem>, source_range: SourceRange, engine: EngineConnection) -> Self {
        Self {
            args,
            source_range,
@ -118,8 +121,12 @@ impl<'a> Args<'a> {
        }
    }

-    pub fn send_modeling_cmd(&mut self, id: uuid::Uuid, cmd: kittycad::types::ModelingCmd) -> Result<(), KclError> {
-        self.engine.send_modeling_cmd(id, self.source_range, cmd)
+    pub async fn send_modeling_cmd(
+        &self,
+        id: uuid::Uuid,
+        cmd: kittycad::types::ModelingCmd,
+    ) -> Result<OkWebSocketResponseData, KclError> {
+        self.engine.send_modeling_cmd(id, self.source_range, cmd).await
    }

    fn make_user_val_from_json(&self, j: serde_json::Value) -> Result<MemoryItem, KclError> {
@ -443,7 +450,7 @@ impl<'a> Args<'a> {

 /// Render a model.
 // This never actually gets called so this is fine.
-pub fn show(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn show<'a>(args: Args) -> Result<MemoryItem, KclError> {
    let sketch_group = args.get_sketch_group()?;
    inner_show(sketch_group);

@ -457,7 +464,7 @@ pub fn show(args: &mut Args) -> Result<MemoryItem, KclError> {
 fn inner_show(_sketch: Box<SketchGroup>) {}

 /// Returns the length of the given leg.
-pub fn leg_length(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn leg_length(args: Args) -> Result<MemoryItem, KclError> {
    let (hypotenuse, leg) = args.get_hypotenuse_leg()?;
    let result = inner_leg_length(hypotenuse, leg);
    args.make_user_val_from_f64(result)
@ -472,7 +479,7 @@ fn inner_leg_length(hypotenuse: f64, leg: f64) -> f64 {
 }

 /// Returns the angle of the given leg for x.
-pub fn leg_angle_x(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn leg_angle_x(args: Args) -> Result<MemoryItem, KclError> {
    let (hypotenuse, leg) = args.get_hypotenuse_leg()?;
    let result = inner_leg_angle_x(hypotenuse, leg);
    args.make_user_val_from_f64(result)
@ -487,7 +494,7 @@ fn inner_leg_angle_x(hypotenuse: f64, leg: f64) -> f64 {
 }

 /// Returns the angle of the given leg for y.
-pub fn leg_angle_y(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn leg_angle_y(args: Args) -> Result<MemoryItem, KclError> {
    let (hypotenuse, leg) = args.get_hypotenuse_leg()?;
    let result = inner_leg_angle_y(hypotenuse, leg);
    args.make_user_val_from_f64(result)
--- a/src/wasm-lib/kcl/src/std/segment.rs
+++ b/src/wasm-lib/kcl/src/std/segment.rs
@ -11,9 +11,9 @@ use crate::{
 };

 /// Returns the segment end of x.
-pub fn segment_end_x(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn segment_end_x(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, sketch_group) = args.get_segment_name_sketch_group()?;
-    let result = inner_segment_end_x(&segment_name, sketch_group, args)?;
+    let result = inner_segment_end_x(&segment_name, sketch_group, args.clone())?;

    args.make_user_val_from_f64(result)
 }
@ -22,7 +22,7 @@ pub fn segment_end_x(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "segEndX",
 }]
-fn inner_segment_end_x(segment_name: &str, sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_segment_end_x(segment_name: &str, sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let line = sketch_group.get_base_by_name_or_start(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
            message: format!(
@ -37,9 +37,9 @@ fn inner_segment_end_x(segment_name: &str, sketch_group: Box<SketchGroup>, args:
 }

 /// Returns the segment end of y.
-pub fn segment_end_y(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn segment_end_y(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, sketch_group) = args.get_segment_name_sketch_group()?;
-    let result = inner_segment_end_y(&segment_name, sketch_group, args)?;
+    let result = inner_segment_end_y(&segment_name, sketch_group, args.clone())?;

    args.make_user_val_from_f64(result)
 }
@ -48,7 +48,7 @@ pub fn segment_end_y(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "segEndY",
 }]
-fn inner_segment_end_y(segment_name: &str, sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_segment_end_y(segment_name: &str, sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let line = sketch_group.get_base_by_name_or_start(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
            message: format!(
@ -63,9 +63,9 @@ fn inner_segment_end_y(segment_name: &str, sketch_group: Box<SketchGroup>, args:
 }

 /// Returns the last segment of x.
-pub fn last_segment_x(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn last_segment_x(args: Args) -> Result<MemoryItem, KclError> {
    let sketch_group = args.get_sketch_group()?;
-    let result = inner_last_segment_x(sketch_group, args)?;
+    let result = inner_last_segment_x(sketch_group, args.clone())?;

    args.make_user_val_from_f64(result)
 }
@ -74,7 +74,7 @@ pub fn last_segment_x(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "lastSegX",
 }]
-fn inner_last_segment_x(sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_last_segment_x(sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let last_line = sketch_group
        .value
        .last()
@ -93,9 +93,9 @@ fn inner_last_segment_x(sketch_group: Box<SketchGroup>, args: &mut Args) -> Resu
 }

 /// Returns the last segment of y.
-pub fn last_segment_y(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn last_segment_y(args: Args) -> Result<MemoryItem, KclError> {
    let sketch_group = args.get_sketch_group()?;
-    let result = inner_last_segment_y(sketch_group, args)?;
+    let result = inner_last_segment_y(sketch_group, args.clone())?;

    args.make_user_val_from_f64(result)
 }
@ -104,7 +104,7 @@ pub fn last_segment_y(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "lastSegY",
 }]
-fn inner_last_segment_y(sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_last_segment_y(sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let last_line = sketch_group
        .value
        .last()
@ -123,9 +123,9 @@ fn inner_last_segment_y(sketch_group: Box<SketchGroup>, args: &mut Args) -> Resu
 }

 /// Returns the length of the segment.
-pub fn segment_length(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn segment_length(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, sketch_group) = args.get_segment_name_sketch_group()?;
-    let result = inner_segment_length(&segment_name, sketch_group, args)?;
+    let result = inner_segment_length(&segment_name, sketch_group, args.clone())?;
    args.make_user_val_from_f64(result)
 }

@ -133,7 +133,7 @@ pub fn segment_length(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "segLen",
 }]
-fn inner_segment_length(segment_name: &str, sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_segment_length(segment_name: &str, sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let path = sketch_group.get_path_by_name(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
            message: format!(
@ -151,10 +151,10 @@ fn inner_segment_length(segment_name: &str, sketch_group: Box<SketchGroup>, args
 }

 /// Returns the angle of the segment.
-pub fn segment_angle(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn segment_angle(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, sketch_group) = args.get_segment_name_sketch_group()?;

-    let result = inner_segment_angle(&segment_name, sketch_group, args)?;
+    let result = inner_segment_angle(&segment_name, sketch_group, args.clone())?;
    args.make_user_val_from_f64(result)
 }

@ -162,7 +162,7 @@ pub fn segment_angle(args: &mut Args) -> Result<MemoryItem, KclError> {
 #[stdlib {
    name = "segAng",
 }]
-fn inner_segment_angle(segment_name: &str, sketch_group: Box<SketchGroup>, args: &mut Args) -> Result<f64, KclError> {
+fn inner_segment_angle(segment_name: &str, sketch_group: Box<SketchGroup>, args: Args) -> Result<f64, KclError> {
    let path = sketch_group.get_path_by_name(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
            message: format!(
@ -180,9 +180,9 @@ fn inner_segment_angle(segment_name: &str, sketch_group: Box<SketchGroup>, args:
 }

 /// Returns the angle to match the given length for x.
-pub fn angle_to_match_length_x(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn angle_to_match_length_x(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, to, sketch_group) = args.get_segment_name_to_number_sketch_group()?;
-    let result = inner_angle_to_match_length_x(&segment_name, to, sketch_group, args)?;
+    let result = inner_angle_to_match_length_x(&segment_name, to, sketch_group, args.clone())?;
    args.make_user_val_from_f64(result)
 }

@ -194,7 +194,7 @@ fn inner_angle_to_match_length_x(
    segment_name: &str,
    to: f64,
    sketch_group: Box<SketchGroup>,
-    args: &mut Args,
+    args: Args,
 ) -> Result<f64, KclError> {
    let path = sketch_group.get_path_by_name(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
@ -235,9 +235,9 @@ fn inner_angle_to_match_length_x(
 }

 /// Returns the angle to match the given length for y.
-pub fn angle_to_match_length_y(args: &mut Args) -> Result<MemoryItem, KclError> {
+pub async fn angle_to_match_length_y(args: Args) -> Result<MemoryItem, KclError> {
    let (segment_name, to, sketch_group) = args.get_segment_name_to_number_sketch_group()?;
-    let result = inner_angle_to_match_length_y(&segment_name, to, sketch_group, args)?;
+    let result = inner_angle_to_match_length_y(&segment_name, to, sketch_group, args.clone())?;
    args.make_user_val_from_f64(result)
 }

@ -249,7 +249,7 @@ fn inner_angle_to_match_length_y(
    segment_name: &str,
    to: f64,
    sketch_group: Box<SketchGroup>,
-    args: &mut Args,
+    args: Args,
 ) -> Result<f64, KclError> {
    let path = sketch_group.get_path_by_name(segment_name).ok_or_else(|| {
        KclError::Type(KclErrorDetails {
--- a/Show More
+++ b/Show More