Merge branch 'main' into pierremtb/issue4472-Add-shell-point-and-click-operation-backup

Co-authored-by: Frank Noirot <frank@zoo.dev>

.github/workflows/build-apps.yml

@@ -165,6 +165,7 @@ jobs:
       - name: Build the app (release)
         if: ${{ env.IS_RELEASE == 'true' || env.IS_NIGHTLY == 'true' }}
         env:
+          PUBLISH_FOR_PULL_REQUEST: true
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_APP_SPECIFIC_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
@@ -172,6 +173,7 @@ jobs:
           CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
           CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
           CSC_KEYCHAIN: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          CSC_FOR_PULL_REQUEST: true
           WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
         run: yarn electron-builder --config --publish always
 
@@ -227,6 +229,7 @@ jobs:
           CSC_LINK: ${{ secrets.APPLE_CERTIFICATE }}
           CSC_KEY_PASSWORD: ${{ secrets.APPLE_CERTIFICATE_PASSWORD }}
           CSC_KEYCHAIN: ${{ secrets.APPLE_SIGNING_IDENTITY }}
+          CSC_FOR_PULL_REQUEST: true
           WINDOWS_CERTIFICATE_THUMBPRINT: ${{ secrets.WINDOWS_CERTIFICATE_THUMBPRINT }}
         run: yarn electron-builder --config --publish always
 

.github/workflows/cargo-test.yml

@@ -71,7 +71,7 @@ jobs:
           KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN}}
           RUST_MIN_STACK: 10485760000
       - name: Upload to codecov.io
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v4
         with:
           token: ${{secrets.CODECOV_TOKEN}}
           fail_ci_if_error: true

docs/kcl/KNOWN-ISSUES.md

@@ -22,5 +22,3 @@ once fixed in engine will just start working here with no language changes.
 
 - **Chamfers**: Chamfers cannot intersect, you will get an error. Only simple
     chamfer cases work currently.
-
-- **Appearance**: Changing the appearance on a loft does not work.

docs/kcl/index.md

@@ -19,7 +19,6 @@ layout: manual
 * [`angledLineThatIntersects`](kcl/angledLineThatIntersects)
 * [`angledLineToX`](kcl/angledLineToX)
 * [`angledLineToY`](kcl/angledLineToY)
-* [`appearance`](kcl/appearance)
 * [`arc`](kcl/arc)
 * [`arcTo`](kcl/arcTo)
 * [`asin`](kcl/asin)
@@ -102,7 +101,6 @@ layout: manual
 * [`startProfileAt`](kcl/startProfileAt)
 * [`startSketchAt`](kcl/startSketchAt)
 * [`startSketchOn`](kcl/startSketchOn)
-* [`sweep`](kcl/sweep)
 * [`tan`](kcl/tan)
 * [`tangentToEnd`](kcl/tangentToEnd)
 * [`tangentialArc`](kcl/tangentialArc)

docs/kcl/map.md

@@ -45,7 +45,7 @@ circles = map([1..3], drawCircle)
 ```js
 r = 10 // radius
 // Call `map`, using an anonymous function instead of a named one.
-circles = map([1..3], fn(id) {
+circles = map([1..3], (id) {
   return startSketchOn("XY")
     |> circle({ center = [id * 2 * r, 0], radius = r }, %)
 })

docs/kcl/reduce.md

@@ -61,7 +61,7 @@ assertEqual(sum([1, 2, 3]), 6, 0.00001, "1 + 2 + 3 summed is 6")
 // an anonymous `add` function as its parameter, instead of declaring a
 // named function outside.
 arr = [1, 2, 3]
-sum = reduce(arr, 0, fn(i, result_so_far) {
+sum = reduce(arr, 0, (i, result_so_far) {
   return i + result_so_far
 })
 
@@ -84,7 +84,7 @@ fn decagon(radius) {
   // Use a `reduce` to draw the remaining decagon sides.
   // For each number in the array 1..10, run the given function,
   // which takes a partially-sketched decagon and adds one more edge to it.
-  fullDecagon = reduce([1..10], startOfDecagonSketch, fn(i, partialDecagon) {
+  fullDecagon = reduce([1..10], startOfDecagonSketch, (i, partialDecagon) {
     // Draw one edge of the decagon.
     x = cos(stepAngle * i) * radius
     y = sin(stepAngle * i) * radius

docs/kcl/types/AppearanceData.md

@@ -1,23 +0,0 @@
----
-title: "AppearanceData"
-excerpt: "Data for appearance."
-layout: manual
----
-
-Data for appearance.
-
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `color` |`string`| Color of the new material, a hex string like "#ff0000". | No |
-| `metalness` |`number` (**maximum:** 100.0)| Metalness of the new material, a percentage like 95.7. | No |
-| `roughness` |`number` (**maximum:** 100.0)| Roughness of the new material, a percentage like 95.7. | No |
-
-

docs/kcl/types/KclNone.md

@@ -12,10 +12,5 @@ KCL value for an optional parameter which was not given an argument. (remember,
 
 
 
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `digest` |`[, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`]`|  | No |
 
 

docs/kcl/types/SweepData.md

@@ -1,23 +0,0 @@
----
-title: "SweepData"
-excerpt: "Data for a sweep."
-layout: manual
----
-
-Data for a sweep.
-
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `path` |[`Sketch`](/docs/kcl/types/Sketch)| The path to sweep along. | No |
-| `sectional` |`boolean`| If true, the sweep will be broken up into sub-sweeps (extrusions, revolves, sweeps) based on the trajectory path components. | No |
-| `tolerance` |`number`| Tolerance for the sweep operation. | No |
-
-

e2e/playwright/basic-sketch.spec.ts

@@ -57,26 +57,23 @@ async function doBasicSketch(page: Page, openPanes: string[]) {
   const startXPx = 600
   await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
   if (openPanes.includes('code')) {
-    await expect(u.codeLocator).toContainText(
-      `sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)`
-    )
+    await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt(${commonPoints.startAt}, %)`)
   }
   await page.waitForTimeout(500)
   await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 10)
   await page.waitForTimeout(500)
 
   if (openPanes.includes('code')) {
-    await expect(u.codeLocator)
-      .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)
+    await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt(${commonPoints.startAt}, %)
   |> xLine(${commonPoints.num1}, %)`)
   }
   await page.waitForTimeout(500)
   await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 20)
   if (openPanes.includes('code')) {
-    await expect(u.codeLocator)
-      .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${
-      commonPoints.startAt
-    }, sketch001)
+    await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt(${commonPoints.startAt}, %)
   |> xLine(${commonPoints.num1}, %)
   |> yLine(${commonPoints.num1 + 0.01}, %)`)
   } else {
@@ -85,10 +82,8 @@ async function doBasicSketch(page: Page, openPanes: string[]) {
   await page.waitForTimeout(200)
   await page.mouse.click(startXPx, 500 - PUR * 20)
   if (openPanes.includes('code')) {
-    await expect(u.codeLocator)
-      .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${
-      commonPoints.startAt
-    }, sketch001)
+    await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt(${commonPoints.startAt}, %)
   |> xLine(${commonPoints.num1}, %)
   |> yLine(${commonPoints.num1 + 0.01}, %)
   |> xLine(${commonPoints.num2 * -1}, %)`)
@@ -145,10 +140,8 @@ async function doBasicSketch(page: Page, openPanes: string[]) {
 
   // Open the code pane.
   await u.openKclCodePanel()
-  await expect(u.codeLocator)
-    .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${
-    commonPoints.startAt
-  }, sketch001)
+  await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt(${commonPoints.startAt}, %)
   |> xLine(${commonPoints.num1}, %, $seg01)
   |> yLine(${commonPoints.num1 + 0.01}, %)
   |> xLine(-segLen(seg01), %)`)

e2e/playwright/can-create-sketches-on-all-planes-and-their-back-sides.spec.ts

@@ -44,7 +44,8 @@ test.describe('Can create sketches on all planes and their back sides', () => {
       },
     }
 
-    const code = `sketch001 = startSketchOn('${plane}')profile001 = startProfileAt([0.9, -1.22], sketch001)`
+    const code = `sketch001 = startSketchOn('${plane}')
+    |> startProfileAt([0.9, -1.22], %)`
 
     await u.openDebugPanel()
 

e2e/playwright/fixtures/sceneFixture.ts

@@ -11,7 +11,6 @@ import {
 
 type mouseParams = {
   pixelDiff?: number
-  shouldDbClick?: boolean
 }
 type mouseDragToParams = mouseParams & {
   fromPoint: { x: number; y: number }
@@ -76,16 +75,11 @@ export class SceneFixture {
         if (clickParams?.pixelDiff) {
           return doAndWaitForImageDiff(
             this.page,
-            () =>
-              clickParams?.shouldDbClick
-                ? this.page.mouse.dblclick(x, y)
-                : this.page.mouse.click(x, y),
+            () => this.page.mouse.click(x, y),
             clickParams.pixelDiff
           )
         }
-        return clickParams?.shouldDbClick
-          ? this.page.mouse.dblclick(x, y)
-          : this.page.mouse.click(x, y)
+        return this.page.mouse.click(x, y)
       },
       (moveParams?: mouseParams) => {
         if (moveParams?.pixelDiff) {

e2e/playwright/fixtures/toolbarFixture.ts

@@ -11,10 +11,7 @@ export class ToolbarFixture {
   offsetPlaneButton!: Locator
   startSketchBtn!: Locator
   lineBtn!: Locator
-  tangentialArcBtn!: Locator
-  circleBtn!: Locator
   rectangleBtn!: Locator
-  lengthConstraintBtn!: Locator
   exitSketchBtn!: Locator
   editSketchBtn!: Locator
   fileTreeBtn!: Locator
@@ -36,10 +33,7 @@ export class ToolbarFixture {
     this.offsetPlaneButton = page.getByTestId('plane-offset')
     this.startSketchBtn = page.getByTestId('sketch')
     this.lineBtn = page.getByTestId('line')
-    this.tangentialArcBtn = page.getByTestId('tangential-arc')
-    this.circleBtn = page.getByTestId('circle-center')
     this.rectangleBtn = page.getByTestId('corner-rectangle')
-    this.lengthConstraintBtn = page.getByTestId('constraint-length')
     this.exitSketchBtn = page.getByTestId('sketch-exit')
     this.editSketchBtn = page.getByText('Edit Sketch')
     this.fileTreeBtn = page.locator('[id="files-button-holder"]')
@@ -97,13 +91,4 @@ export class ToolbarFixture {
       await expect(this.exeIndicator).toBeVisible({ timeout: 15_000 })
     }
   }
-  selectCenterRectangle = async () => {
-    await this.page
-      .getByRole('button', { name: 'caret down Corner rectangle:' })
-      .click()
-    await expect(
-      this.page.getByTestId('dropdown-center-rectangle')
-    ).toBeVisible()
-    await this.page.getByTestId('dropdown-center-rectangle').click()
-  }
 }

e2e/playwright/point-click.spec.ts

@@ -135,9 +135,7 @@ test.describe('verify sketch on chamfer works', () => {
           pixelDiff: 50,
         })
         await rectangle2ndClick()
-        await editor.expectEditor.toContain(afterRectangle2ndClickSnippet, {
-          shouldNormalise: true,
-        })
+        await editor.expectEditor.toContain(afterRectangle2ndClickSnippet)
       })
 
       await test.step('Clean up so that `_sketchOnAChamfer` util can be called again', async () => {
@@ -179,13 +177,18 @@ test.describe('verify sketch on chamfer works', () => {
 
         afterChamferSelectSnippet:
           'sketch002 = startSketchOn(extrude001, seg03)',
-        afterRectangle1stClickSnippet:
-          'startProfileAt([205.96, 254.59], sketch002)',
-        afterRectangle2ndClickSnippet: `angledLine([0,11.39],%,$rectangleSegmentA002)
-        |>angledLine([segAng(rectangleSegmentA002)-90,105.26],%)
-        |>angledLine([segAng(rectangleSegmentA002),-segLen(rectangleSegmentA002)],%)
-        |>lineTo([profileStartX(%),profileStartY(%)],%)
-        |>close(%)`,
+        afterRectangle1stClickSnippet: 'startProfileAt([205.96, 254.59], %)',
+        afterRectangle2ndClickSnippet: `angledLine([0, 11.39], %, $rectangleSegmentA002)
+    |> angledLine([
+         segAng(rectangleSegmentA002) - 90,
+         105.26
+       ], %, $rectangleSegmentB001)
+    |> angledLine([
+         segAng(rectangleSegmentA002),
+         -segLen(rectangleSegmentA002)
+       ], %, $rectangleSegmentC001)
+    |> lineTo([profileStartX(%), profileStartY(%)], %)
+    |> close(%)`,
       })
 
       await sketchOnAChamfer({
@@ -206,15 +209,19 @@ test.describe('verify sketch on chamfer works', () => {
 
         afterChamferSelectSnippet:
           'sketch003 = startSketchOn(extrude001, seg04)',
-        afterRectangle1stClickSnippet:
-          'startProfileAt([-209.64, 255.28], sketch003)',
-        afterRectangle2ndClickSnippet: `angledLine([0,11.56],%,$rectangleSegmentA003)
-        |>angledLine([segAng(rectangleSegmentA003)-90,106.84],%)
-        |>angledLine([segAng(rectangleSegmentA003),-segLen(rectangleSegmentA003)],%)
-        |>lineTo([profileStartX(%),profileStartY(%)],%)
-        |>close(%)`,
+        afterRectangle1stClickSnippet: 'startProfileAt([-209.64, 255.28], %)',
+        afterRectangle2ndClickSnippet: `angledLine([0, 11.56], %, $rectangleSegmentA003)
+    |> angledLine([
+         segAng(rectangleSegmentA003) - 90,
+         106.84
+       ], %, $rectangleSegmentB002)
+    |> angledLine([
+         segAng(rectangleSegmentA003),
+         -segLen(rectangleSegmentA003)
+       ], %, $rectangleSegmentC002)
+    |> lineTo([profileStartX(%), profileStartY(%)], %)
+    |> close(%)`,
       })
-
       await sketchOnAChamfer({
         clickCoords: { x: 677, y: 87 },
         cameraPos: { x: -6200, y: 1500, z: 6200 },
@@ -227,14 +234,19 @@ test.describe('verify sketch on chamfer works', () => {
          ]
        }, %)`,
         afterChamferSelectSnippet:
-          'sketch004 = startSketchOn(extrude001, seg05)',
-        afterRectangle1stClickSnippet:
-          'startProfileAt([82.57, 322.96], sketch004)',
-        afterRectangle2ndClickSnippet: `angledLine([0,11.16],%,$rectangleSegmentA004)
-        |>angledLine([segAng(rectangleSegmentA004)-90,103.07],%)
-        |>angledLine([segAng(rectangleSegmentA004),-segLen(rectangleSegmentA004)],%)
-        |>lineTo([profileStartX(%),profileStartY(%)],%)|
-        >close(%)`,
+          'sketch003 = startSketchOn(extrude001, seg04)',
+        afterRectangle1stClickSnippet: 'startProfileAt([-209.64, 255.28], %)',
+        afterRectangle2ndClickSnippet: `angledLine([0, 11.56], %, $rectangleSegmentA003)
+    |> angledLine([
+         segAng(rectangleSegmentA003) - 90,
+         106.84
+       ], %, $rectangleSegmentB002)
+    |> angledLine([
+         segAng(rectangleSegmentA003),
+         -segLen(rectangleSegmentA003)
+       ], %, $rectangleSegmentC002)
+    |> lineTo([profileStartX(%), profileStartY(%)], %)
+    |> close(%)`,
       })
       /// last one
       await sketchOnAChamfer({
@@ -247,97 +259,104 @@ test.describe('verify sketch on chamfer works', () => {
        }, %)`,
         afterChamferSelectSnippet:
           'sketch005 = startSketchOn(extrude001, seg06)',
-        afterRectangle1stClickSnippet:
-          'startProfileAt([-23.43, 19.69], sketch005)',
-        afterRectangle2ndClickSnippet: `angledLine([0,9.1],%,$rectangleSegmentA005)
-        |>angledLine([segAng(rectangleSegmentA005)-90,84.07],%)
-        |>angledLine([segAng(rectangleSegmentA005),-segLen(rectangleSegmentA005)],%)
-        |>lineTo([profileStartX(%),profileStartY(%)],%)
-        |>close(%)`,
+        afterRectangle1stClickSnippet: 'startProfileAt([-23.43, 19.69], %)',
+        afterRectangle2ndClickSnippet: `angledLine([0, 9.1], %, $rectangleSegmentA005)
+
+    |> angledLine([
+         segAng(rectangleSegmentA005) - 90,
+         84.07
+       ], %, $rectangleSegmentB004)
+    |> angledLine([
+         segAng(rectangleSegmentA005),
+         -segLen(rectangleSegmentA005)
+       ], %, $rectangleSegmentC004)
+    |> lineTo([profileStartX(%), profileStartY(%)], %)
+    |> close(%)`,
       })
 
       await test.step('verify at the end of the test that final code is what is expected', async () => {
         await editor.expectEditor.toContain(
           `sketch001 = startSketchOn('XZ')
-  |> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
-  |> angledLine([0, 268.43], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       217.26
-     ], %, $seg01)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %, $yo)
-  |> lineTo([profileStartX(%), profileStartY(%)], %, $seg02)
-  |> close(%)
-extrude001 = extrude(100, sketch001)
-  |> chamfer({
-       length = 30,
-       tags = [getOppositeEdge(seg01)]
-     }, %, $seg03)
-  |> chamfer({ length = 30, tags = [seg01] }, %, $seg04)
-  |> chamfer({
-       length = 30,
-       tags = [getNextAdjacentEdge(seg02)]
-     }, %, $seg05)
-  |> chamfer({
-       length = 30,
-       tags = [getNextAdjacentEdge(yo)]
-     }, %, $seg06)
-sketch005 = startSketchOn(extrude001, seg06)
-profile004 = startProfileAt([-23.43, 19.69], sketch005)
-  |> angledLine([0, 9.1], %, $rectangleSegmentA005)
-  |> angledLine([
-       segAng(rectangleSegmentA005) - 90,
-       84.07
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA005),
-       -segLen(rectangleSegmentA005)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-sketch004 = startSketchOn(extrude001, seg05)
-profile003 = startProfileAt([82.57, 322.96], sketch004)
-  |> angledLine([0, 11.16], %, $rectangleSegmentA004)
-  |> angledLine([
-       segAng(rectangleSegmentA004) - 90,
-       103.07
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA004),
-       -segLen(rectangleSegmentA004)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-sketch003 = startSketchOn(extrude001, seg04)
-profile002 = startProfileAt([-209.64, 255.28], sketch003)
-  |> angledLine([0, 11.56], %, $rectangleSegmentA003)
-  |> angledLine([
-       segAng(rectangleSegmentA003) - 90,
-       106.84
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA003),
-       -segLen(rectangleSegmentA003)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-sketch002 = startSketchOn(extrude001, seg03)
-profile001 = startProfileAt([205.96, 254.59], sketch002)
-  |> angledLine([0, 11.39], %, $rectangleSegmentA002)
-  |> angledLine([
-       segAng(rectangleSegmentA002) - 90,
-       105.26
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA002),
-       -segLen(rectangleSegmentA002)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-`,
+
+      |> startProfileAt([75.8, 317.2], %) // [$startCapTag, $EndCapTag]
+      |> angledLine([0, 268.43], %, $rectangleSegmentA001)
+      |> angledLine([
+           segAng(rectangleSegmentA001) - 90,
+           217.26
+         ], %, $seg01)
+      |> angledLine([
+           segAng(rectangleSegmentA001),
+           -segLen(rectangleSegmentA001)
+         ], %, $yo)
+      |> lineTo([profileStartX(%), profileStartY(%)], %, $seg02)
+      |> close(%)
+    extrude001 = extrude(100, sketch001)
+      |> chamfer({
+           length = 30,
+           tags = [getOppositeEdge(seg01)]
+         }, %, $seg03)
+      |> chamfer({ length = 30, tags = [seg01] }, %, $seg04)
+      |> chamfer({
+           length = 30,
+           tags = [getNextAdjacentEdge(seg02)]
+         }, %, $seg05)
+      |> chamfer({
+           length = 30,
+           tags = [getNextAdjacentEdge(yo)]
+         }, %, $seg06)
+    sketch005 = startSketchOn(extrude001, seg06)
+      |> startProfileAt([-23.43, 19.69], %)
+      |> angledLine([0, 9.1], %, $rectangleSegmentA005)
+      |> angledLine([
+           segAng(rectangleSegmentA005) - 90,
+           84.07
+         ], %, $rectangleSegmentB004)
+      |> angledLine([
+           segAng(rectangleSegmentA005),
+           -segLen(rectangleSegmentA005)
+         ], %, $rectangleSegmentC004)
+      |> lineTo([profileStartX(%), profileStartY(%)], %)
+      |> close(%)
+    sketch004 = startSketchOn(extrude001, seg05)
+      |> startProfileAt([82.57, 322.96], %)
+      |> angledLine([0, 11.16], %, $rectangleSegmentA004)
+      |> angledLine([
+           segAng(rectangleSegmentA004) - 90,
+           103.07
+         ], %, $rectangleSegmentB003)
+      |> angledLine([
+           segAng(rectangleSegmentA004),
+           -segLen(rectangleSegmentA004)
+         ], %, $rectangleSegmentC003)
+      |> lineTo([profileStartX(%), profileStartY(%)], %)
+      |> close(%)
+    sketch003 = startSketchOn(extrude001, seg04)
+      |> startProfileAt([-209.64, 255.28], %)
+      |> angledLine([0, 11.56], %, $rectangleSegmentA003)
+      |> angledLine([
+           segAng(rectangleSegmentA003) - 90,
+           106.84
+         ], %, $rectangleSegmentB002)
+      |> angledLine([
+           segAng(rectangleSegmentA003),
+           -segLen(rectangleSegmentA003)
+         ], %, $rectangleSegmentC002)
+      |> lineTo([profileStartX(%), profileStartY(%)], %)
+      |> close(%)
+    sketch002 = startSketchOn(extrude001, seg03)
+      |> startProfileAt([205.96, 254.59], %)
+      |> angledLine([0, 11.39], %, $rectangleSegmentA002)
+      |> angledLine([
+           segAng(rectangleSegmentA002) - 90,
+           105.26
+         ], %, $rectangleSegmentB001)
+      |> angledLine([
+           segAng(rectangleSegmentA002),
+           -segLen(rectangleSegmentA002)
+         ], %, $rectangleSegmentC001)
+      |> lineTo([profileStartX(%), profileStartY(%)], %)
+      |> close(%)
+    `,
           { shouldNormalise: true }
         )
       })
@@ -373,13 +392,18 @@ profile001 = startProfileAt([205.96, 254.59], sketch002)
         beforeChamferSnippetEnd: '}, extrude001)',
         afterChamferSelectSnippet:
           'sketch002 = startSketchOn(extrude001, seg03)',
-        afterRectangle1stClickSnippet:
-          'startProfileAt([205.96, 254.59], sketch002)',
-        afterRectangle2ndClickSnippet: `angledLine([0,11.39],%,$rectangleSegmentA002)
-        |>angledLine([segAng(rectangleSegmentA002)-90,105.26],%)
-        |>angledLine([segAng(rectangleSegmentA002),-segLen(rectangleSegmentA002)],%)
-        |>lineTo([profileStartX(%),profileStartY(%)],%)
-        |>close(%)`,
+        afterRectangle1stClickSnippet: 'startProfileAt([205.96, 254.59], %)',
+        afterRectangle2ndClickSnippet: `angledLine([0, 11.39], %, $rectangleSegmentA002)
+    |> angledLine([
+         segAng(rectangleSegmentA002) - 90,
+         105.26
+       ], %, $rectangleSegmentB001)
+    |> angledLine([
+         segAng(rectangleSegmentA002),
+         -segLen(rectangleSegmentA002)
+       ], %, $rectangleSegmentC001)
+    |> lineTo([profileStartX(%), profileStartY(%)], %)
+    |> close(%)`,
       })
       await editor.expectEditor.toContain(
         `sketch001 = startSketchOn('XZ')
@@ -409,16 +433,16 @@ chamf = chamfer({
        ]
      }, %)
 sketch002 = startSketchOn(extrude001, seg03)
-profile001 = startProfileAt([205.96, 254.59], sketch002)
+  |> startProfileAt([205.96, 254.59], %)
   |> angledLine([0, 11.39], %, $rectangleSegmentA002)
   |> angledLine([
        segAng(rectangleSegmentA002) - 90,
        105.26
-     ], %)
+     ], %, $rectangleSegmentB001)
   |> angledLine([
        segAng(rectangleSegmentA002),
        -segLen(rectangleSegmentA002)
-     ], %)
+     ], %, $rectangleSegmentC001)
   |> lineTo([profileStartX(%), profileStartY(%)], %)
   |> close(%)
 `,
@@ -480,10 +504,10 @@ test(`Verify axis, origin, and horizontal snapping`, async ({
 
   const expectedCodeSnippets = {
     sketchOnXzPlane: `sketch001 = startSketchOn('XZ')`,
-    pointAtOrigin: `startProfileAt([${originSloppy.kcl[0]}, ${originSloppy.kcl[1]}], sketch001)`,
+    pointAtOrigin: `startProfileAt([${originSloppy.kcl[0]}, ${originSloppy.kcl[1]}], %)`,
     segmentOnXAxis: `xLine(${xAxisSloppy.kcl[0]}, %)`,
-    afterSegmentDraggedOffYAxis: `startProfileAt([${offYAxis.kcl[0]}, ${offYAxis.kcl[1]}], sketch001)`,
-    afterSegmentDraggedOnYAxis: `startProfileAt([${yAxisSloppy.kcl[0]}, ${yAxisSloppy.kcl[1]}], sketch001)`,
+    afterSegmentDraggedOffYAxis: `startProfileAt([${offYAxis.kcl[0]}, ${offYAxis.kcl[1]}], %)`,
+    afterSegmentDraggedOnYAxis: `startProfileAt([${yAxisSloppy.kcl[0]}, ${yAxisSloppy.kcl[1]}], %)`,
   }
 
   await app.initialise()
@@ -668,10 +692,10 @@ loftPointAndClickCases.forEach(({ shouldPreselect }) => {
     cmdBar,
   }) => {
     const initialCode = `sketch001 = startSketchOn('XZ')
-profile001 = circle({ center = [0, 0], radius = 30 }, sketch001)
-plane001 = offsetPlane('XZ', 50)
-sketch002 = startSketchOn(plane001)
-profile002 = circle({ center = [0, 0], radius = 20 }, sketch002)
+    |> circle({ center = [0, 0], radius = 30 }, %)
+    plane001 = offsetPlane('XZ', 50)
+    sketch002 = startSketchOn(plane001)
+    |> circle({ center = [0, 0], radius = 20 }, %)
 `
     await app.initialise(initialCode)
 
@@ -682,7 +706,7 @@ profile002 = circle({ center = [0, 0], radius = 20 }, sketch002)
       testPoint.x,
       testPoint.y + 80
     )
-    const loftDeclaration = 'loft001 = loft([profile001, profile002])'
+    const loftDeclaration = 'loft001 = loft([sketch001, sketch002])'
 
     await test.step(`Look for the white of the sketch001 shape`, async () => {
       await scene.expectPixelColor([254, 254, 254], testPoint, 15)
@@ -788,7 +812,6 @@ shellPointAndClickCapCases.forEach(({ shouldPreselect }) => {
           commandName: 'Shell',
         })
         await clickOnCap()
-        await app.page.waitForTimeout(500)
         await cmdBar.progressCmdBar()
         await cmdBar.progressCmdBar()
         await cmdBar.expectState({
@@ -804,7 +827,6 @@ shellPointAndClickCapCases.forEach(({ shouldPreselect }) => {
     } else {
       await test.step(`Preselect the cap`, async () => {
         await clickOnCap()
-        await app.page.waitForTimeout(500)
       })
 
       await test.step(`Go through the command bar flow with a preselected face (cap)`, async () => {

e2e/playwright/sketch-tests.spec.ts

@@ -114,9 +114,9 @@ test.describe('Sketch tests', () => {
       localStorage.setItem(
         'persistCode',
         `sketch001 = startSketchOn('XZ')
-  |> startProfileAt([2.61, -4.01], %)
-  |> xLine(8.73, %)
-  |> tangentialArcTo([8.33, -1.31], %)`
+  |> startProfileAt([4.61, -14.01], %)
+  |> xLine(12.73, %)
+  |> tangentialArcTo([24.95, -5.38], %)`
       )
     })
 
@@ -126,7 +126,7 @@ test.describe('Sketch tests', () => {
 
     await expect(async () => {
       await page.mouse.click(700, 200)
-      await page.getByText('tangentialArcTo([8.33, -1.31], %)').click()
+      await page.getByText('tangentialArcTo([24.95, -5.38], %)').click()
       await expect(
         page.getByRole('button', { name: 'Edit Sketch' })
       ).toBeEnabled({ timeout: 1000 })
@@ -135,7 +135,7 @@ test.describe('Sketch tests', () => {
 
     await page.waitForTimeout(600) // wait for animation
 
-    await page.getByText('tangentialArcTo([8.33, -1.31], %)').click()
+    await page.getByText('tangentialArcTo([24.95, -5.38], %)').click()
     await page.keyboard.press('End')
     await page.keyboard.down('Shift')
     await page.keyboard.press('ArrowUp')
@@ -149,21 +149,17 @@ test.describe('Sketch tests', () => {
 
     await page.getByRole('button', { name: 'line Line', exact: true }).click()
     await page.waitForTimeout(100)
-    // click start profileAt handle to continue profile
-    await page.mouse.click(702, 407)
-    await page.waitForTimeout(100)
 
     await expect(async () => {
-      // click to add segment
       await page.mouse.click(700, 200)
 
       await expect.poll(u.normalisedEditorCode, { timeout: 1000 })
-        .toBe(`sketch002 = startSketchOn('XZ')
-sketch001 = startProfileAt([12.34, -12.34], sketch002)
+        .toBe(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt([12.34, -12.34], %)
   |> yLine(12.34, %)
 
 `)
-    }).toPass({ timeout: 5_000, intervals: [1_000] })
+    }).toPass({ timeout: 40_000, intervals: [1_000] })
   })
   test('Can exit selection of face', async ({ page }) => {
     // Load the app with the code panes
@@ -673,7 +669,7 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
     await page.waitForTimeout(500) // TODO detect animation ending, or disable animation
 
     await click00r(0, 0)
-    codeStr += `profile001 = startProfileAt(${toSU([0, 0])}, sketch001)`
+    codeStr += `  |> startProfileAt(${toSU([0, 0])}, %)`
     await expect(u.codeLocator).toHaveText(codeStr)
 
     await click00r(50, 0)
@@ -709,7 +705,7 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
     await u.closeDebugPanel()
 
     await click00r(30, 0)
-    codeStr += `profile002 = startProfileAt([2.03, 0], sketch002)`
+    codeStr += `  |> startProfileAt([2.03, 0], %)`
     await expect(u.codeLocator).toHaveText(codeStr)
 
     // TODO: I couldn't use `toSU` here because of some rounding error causing
@@ -746,9 +742,7 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
       await u.openDebugPanel()
 
       const code = `sketch001 = startSketchOn('-XZ')
-profile001 = startProfileAt([${roundOff(scale * 69.6)}, ${roundOff(
-        scale * 34.8
-      )}], sketch001)
+    |> startProfileAt([${roundOff(scale * 69.6)}, ${roundOff(scale * 34.8)}], %)
     |> xLine(${roundOff(scale * 139.19)}, %)
     |> yLine(-${roundOff(scale * 139.2)}, %)
     |> lineTo([profileStartX(%), profileStartY(%)], %)
@@ -814,17 +808,11 @@ profile001 = startProfileAt([${roundOff(scale * 69.6)}, ${roundOff(
       await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
       prevContent = await page.locator('.cm-content').innerText()
 
-      await expect
-        .poll(async () => {
-          const text = await page.locator('.cm-content').innerText()
-          return text.replace(/\s/g, '')
-        })
-        .toBe(code.replace(/\s/g, ''))
-
-      // Assert the tool stays equipped after a profile is closed (ready for the next one)
+      await expect(page.locator('.cm-content')).toHaveText(code)
+      // Assert the tool was unequipped
       await expect(
         page.getByRole('button', { name: 'line Line', exact: true })
-      ).toHaveAttribute('aria-pressed', 'true')
+      ).not.toHaveAttribute('aria-pressed', 'true')
 
       // exit sketch
       await u.openAndClearDebugPanel()
@@ -1142,17 +1130,11 @@ sketch002 = startSketchOn(extrude001, 'END')
     await page.mouse.click(XYPlanePoint.x, XYPlanePoint.y)
     await page.waitForTimeout(200)
     await page.mouse.click(XYPlanePoint.x + 50, XYPlanePoint.y + 50)
-    await expect
-      .poll(async () => {
-        const text = await u.codeLocator.innerText()
-        return text.replace(/\s/g, '')
-      })
-      .toBe(
-        `sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([11.8, 9.09], sketch001)
-   |> line([3.39, -3.39], %)
-`.replace(/\s/g, '')
-      )
+    await expect(u.codeLocator).toHaveText(`sketch001 = startSketchOn('XZ')
+  |> startProfileAt([11.8, 9.09], %)
+  |> line([3.39, -3.39], %)
+`)
+
     await page.addInitScript(async () => {
       localStorage.setItem(
         'persistCode',
@@ -1437,560 +1419,3 @@ test2.describe(`Sketching with offset planes`, () => {
     }
   )
 })
-
-test2.describe('multi-profile sketching', () => {
-  test2(
-    'Can add multiple profiles to a sketch (all tool types)',
-    async ({ app, scene, toolbar, editor }) => {
-      await app.initialise(``)
-
-      const [selectXZPlane] = scene.makeMouseHelpers(650, 150)
-
-      const [startProfile1] = scene.makeMouseHelpers(568, 70)
-      const [endLineStartTanArc] = scene.makeMouseHelpers(701, 78)
-      const [endArcStartLine] = scene.makeMouseHelpers(745, 189)
-
-      const [startProfile2] = scene.makeMouseHelpers(782, 80)
-      const [profile2Point2] = scene.makeMouseHelpers(921, 90)
-      const [profile2Point3] = scene.makeMouseHelpers(953, 178)
-
-      const [circle1Center] = scene.makeMouseHelpers(842, 147)
-      const [circle1Radius] = scene.makeMouseHelpers(870, 171)
-
-      const [circle2Center] = scene.makeMouseHelpers(850, 222)
-      const [circle2Radius] = scene.makeMouseHelpers(843, 230)
-
-      const [crnRect1point1] = scene.makeMouseHelpers(583, 205)
-      const [crnRect1point2] = scene.makeMouseHelpers(618, 320)
-
-      const [crnRect2point1] = scene.makeMouseHelpers(663, 215)
-      const [crnRect2point2] = scene.makeMouseHelpers(744, 276)
-
-      const [cntrRect1point1] = scene.makeMouseHelpers(624, 387)
-      const [cntrRect1point2] = scene.makeMouseHelpers(676, 355)
-
-      const [cntrRect2point1] = scene.makeMouseHelpers(785, 332)
-      const [cntrRect2point2] = scene.makeMouseHelpers(808, 286)
-
-      await toolbar.startSketchPlaneSelection()
-      await selectXZPlane()
-      // timeout wait for engine animation is unavoidable
-      await app.page.waitForTimeout(600)
-      await editor.expectEditor.toContain(`sketch001 = startSketchOn('XZ')`)
-      await test.step('Create a close profile stopping mid profile to equip the tangential arc, and than back to the line tool', async () => {
-        await startProfile1()
-        await editor.expectEditor.toContain(
-          `profile001 = startProfileAt([4.61, 12.21], sketch001)`
-        )
-
-        await endLineStartTanArc()
-        await editor.expectEditor.toContain(`|> line([9.02, -0.55], %)`)
-        await toolbar.tangentialArcBtn.click()
-        await app.page.waitForTimeout(100)
-        await endLineStartTanArc()
-
-        await endArcStartLine()
-        await editor.expectEditor.toContain(
-          `|> tangentialArcTo([16.61, 4.14], %)`
-        )
-        await toolbar.lineBtn.click()
-        await app.page.waitForTimeout(100)
-        await endArcStartLine()
-
-        await app.page.mouse.click(572, 110)
-        await editor.expectEditor.toContain(`|> line([-11.73, 5.35], %)`)
-        await startProfile1()
-        await editor.expectEditor
-          .toContain(`|> lineTo([profileStartX(%), profileStartY(%)], %)
-      |> close(%)`)
-        await app.page.waitForTimeout(100)
-      })
-
-      await test.step('Without unequipping from the last step, make another profile, and one that is not closed', async () => {
-        await startProfile2()
-        await editor.expectEditor.toContain(
-          `profile002 = startProfileAt([19.12, 11.53], sketch001)`
-        )
-        await profile2Point2()
-        await editor.expectEditor.toContain(`|> line([9.43, -0.68], %)`)
-        await profile2Point3()
-        await editor.expectEditor.toContain(`|> line([2.17, -5.97], %)`)
-      })
-
-      await test.step('create two circles in a row without unequip', async () => {
-        await toolbar.circleBtn.click()
-
-        await circle1Center()
-        await app.page.waitForTimeout(100)
-        await circle1Radius()
-        await editor.expectEditor.toContain(
-          `profile003 = circle({ center = [23.19, 6.98], radius = 2.5 }, sketch001)`
-        )
-
-        await test.step('hover in empty space to wait for overlays to get out of the way', async () => {
-          await app.page.mouse.move(951, 223)
-          await app.page.waitForTimeout(1000)
-        })
-
-        await circle2Center()
-        await app.page.waitForTimeout(100)
-        await circle2Radius()
-        await editor.expectEditor.toContain(
-          `profile004 = circle({ center = [23.74, 1.9], radius = 0.72 }, sketch001)`
-        )
-      })
-      await test.step('create two corner rectangles in a row without unequip', async () => {
-        await toolbar.rectangleBtn.click()
-
-        await crnRect1point1()
-        await editor.expectEditor.toContain(
-          `profile005 = startProfileAt([5.63, 3.05], sketch001)`
-        )
-        await crnRect1point2()
-        await editor.expectEditor
-          .toContain(`|> angledLine([0, 2.37], %, $rectangleSegmentA001)
-  |> angledLine([segAng(rectangleSegmentA001) - 90, 7.8], %)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)`)
-        await app.page.waitForTimeout(100)
-
-        await crnRect2point1()
-        await editor.expectEditor.toContain(
-          `profile006 = startProfileAt([11.05, 2.37], sketch001)`
-        )
-        await crnRect2point2()
-        await editor.expectEditor
-          .toContain(`|> angledLine([0, 5.49], %, $rectangleSegmentA002)
-  |> angledLine([
-       segAng(rectangleSegmentA002) - 90,
-       4.14
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA002),
-       -segLen(rectangleSegmentA002)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)`)
-      })
-
-      await test.step('create two center rectangles in a row without unequip', async () => {
-        await toolbar.selectCenterRectangle()
-
-        await cntrRect1point1()
-        await editor.expectEditor.toContain(
-          `profile007 = startProfileAt([8.41, -9.29], sketch001)`
-        )
-        await cntrRect1point2()
-        await editor.expectEditor
-          .toContain(`|> angledLine([0, 7.06], %, $rectangleSegmentA003)
-|> angledLine([
-     segAng(rectangleSegmentA003) + 90,
-     4.34
-   ], %)
-|> angledLine([
-     segAng(rectangleSegmentA003),
-     -segLen(rectangleSegmentA003)
-   ], %)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)`)
-        await app.page.waitForTimeout(100)
-
-        await cntrRect2point1()
-        await editor.expectEditor.toContain(
-          `profile008 = startProfileAt([19.33, -5.56], sketch001)`
-        )
-        await cntrRect2point2()
-        await editor.expectEditor
-          .toContain(`|> angledLine([0, 3.12], %, $rectangleSegmentA004)
-|> angledLine([
-     segAng(rectangleSegmentA004) + 90,
-     6.24
-   ], %)
-|> angledLine([
-     segAng(rectangleSegmentA004),
-     -segLen(rectangleSegmentA004)
-   ], %)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)`)
-      })
-    }
-  )
-
-  test2(
-    'Can edit a sketch with multiple profiles, dragging segments to edit them, and adding one new profile',
-    async ({ app, scene, toolbar, editor }) => {
-      await app.initialise(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([6.24, 4.54], sketch001)
-  |> line([-0.41, 6.99], %)
-  |> line([8.61, 0.74], %)
-  |> line([10.99, -5.22], %)
-profile002 = startProfileAt([11.19, 5.02], sketch001)
-  |> angledLine([0, 10.78], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       4.14
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-profile003 = circle({ center = [6.92, -4.2], radius = 3.16 }, sketch001)
-`)
-
-      const [pointOnSegment] = scene.makeMouseHelpers(590, 141)
-      const [profileEnd] = scene.makeMouseHelpers(970, 105)
-      const profileEndMv = scene.makeMouseHelpers(951, 101)[1]
-      const [newProfileEnd] = scene.makeMouseHelpers(764, 104)
-      const dragSegmentTo = scene.makeMouseHelpers(850, 104)[1]
-
-      const rectHandle = scene.makeMouseHelpers(901, 150)[1]
-      const rectDragTo = scene.makeMouseHelpers(901, 180)[1]
-
-      const circleEdge = scene.makeMouseHelpers(691, 331)[1]
-      const dragCircleTo = scene.makeMouseHelpers(720, 331)[1]
-
-      const [rectStart] = scene.makeMouseHelpers(794, 322)
-      const [rectEnd] = scene.makeMouseHelpers(757, 395)
-
-      await test2.step('enter sketch and setup', async () => {
-        await pointOnSegment({ shouldDbClick: true })
-        await app.page.waitForTimeout(600)
-
-        await toolbar.lineBtn.click()
-        await app.page.waitForTimeout(100)
-      })
-
-      await test2.step('extend existing profile', async () => {
-        await profileEnd()
-        await app.page.waitForTimeout(100)
-        await newProfileEnd()
-        await editor.expectEditor.toContain(`|> line([-11.4, 0.71], %)`)
-        await toolbar.lineBtn.click()
-        await app.page.waitForTimeout(100)
-      })
-
-      await test2.step('edit existing profile', async () => {
-        await profileEndMv()
-        await app.page.mouse.down()
-        await dragSegmentTo()
-        await app.page.mouse.up()
-        await editor.expectEditor.toContain(`line([4.16, -4.51], %)`)
-      })
-
-      await test2.step('edit existing rect', async () => {
-        await rectHandle()
-        await app.page.mouse.down()
-        await rectDragTo()
-        await app.page.mouse.up()
-        await editor.expectEditor.toContain(
-          `angledLine([-7, 10.2], %, $rectangleSegmentA001)`
-        )
-      })
-
-      await test2.step('edit existing circl', async () => {
-        await circleEdge()
-        await app.page.mouse.down()
-        await dragCircleTo()
-        await app.page.mouse.up()
-        await editor.expectEditor.toContain(
-          `profile003 = circle({ center = [6.92, -4.2], radius = 4.77 }, sketch001)`
-        )
-      })
-
-      await test2.step('add new profile', async () => {
-        await toolbar.rectangleBtn.click()
-        await app.page.waitForTimeout(100)
-        await rectStart()
-        await editor.expectEditor.toContain(
-          `profile004 = startProfileAt([15.62, -3.83], sketch001)`
-        )
-        await app.page.waitForTimeout(100)
-        await rectEnd()
-        await editor.expectEditor
-          .toContain(`|> angledLine([180, 1.97], %, $rectangleSegmentA002)
-    |> angledLine([
-         segAng(rectangleSegmentA002) + 90,
-         3.88
-       ], %)
-    |> angledLine([
-         segAng(rectangleSegmentA002),
-         -segLen(rectangleSegmentA002)
-       ], %)
-    |> lineTo([profileStartX(%), profileStartY(%)], %)
-    |> close(%)`)
-      })
-    }
-  )
-  test2(
-    'Can delete a profile in the editor while is sketch mode, and sketch mode does not break, can ctrl+z to undo after constraint with variable was added',
-    async ({ app, scene, toolbar, editor, cmdBar }) => {
-      await app.initialise(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([6.24, 4.54], sketch001)
-  |> line([-0.41, 6.99], %)
-  |> line([8.61, 0.74], %)
-  |> line([10.99, -5.22], %)
-profile002 = startProfileAt([11.19, 5.02], sketch001)
-  |> angledLine([0, 10.78], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       4.14
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-profile003 = circle({ center = [6.92, -4.2], radius = 3.16 }, sketch001)
-`)
-
-      const [pointOnSegment] = scene.makeMouseHelpers(590, 141)
-      const [segment1Click] = scene.makeMouseHelpers(616, 131)
-      const sketchIsDrawnProperly = async () => {
-        await test2.step(
-          'check the sketch is still drawn properly',
-          async () => {
-            await app.page.waitForTimeout(200)
-            await scene.expectPixelColor(
-              [255, 255, 255],
-              { x: 617, y: 163 },
-              15
-            )
-            await scene.expectPixelColor(
-              [255, 255, 255],
-              { x: 629, y: 331 },
-              15
-            )
-          }
-        )
-      }
-
-      await test2.step('enter sketch and setup', async () => {
-        await pointOnSegment({ shouldDbClick: true })
-        await app.page.waitForTimeout(600)
-
-        await toolbar.lineBtn.click()
-        await app.page.waitForTimeout(100)
-      })
-
-      await test2.step('select and delete code for a profile', async () => {})
-      await app.page.getByText('close(%)').click()
-      await app.page.keyboard.down('Shift')
-      for (let i = 0; i < 11; i++) {
-        await app.page.keyboard.press('ArrowUp')
-      }
-      await app.page.keyboard.press('Home')
-      await app.page.keyboard.up('Shift')
-      await app.page.keyboard.press('Backspace')
-
-      await sketchIsDrawnProperly()
-
-      await test2.step('add random new var between profiles', async () => {
-        await app.page.keyboard.type('myVar = 5')
-        await app.page.keyboard.press('Enter')
-        await app.page.waitForTimeout(600)
-      })
-
-      await sketchIsDrawnProperly()
-
-      await test2.step(
-        'Adding a constraint with a variable, and than ctrl-z-ing which will remove the variable again does not break sketch mode',
-        async () => {
-          await expect(async () => {
-            await segment1Click()
-            await editor.expectState({
-              diagnostics: [],
-              activeLines: ['|>line([-0.41,6.99],%)'],
-              highlightedCode: 'line([-0.41,6.99],%)',
-            })
-          }).toPass({ timeout: 5_000, intervals: [500] })
-
-          await toolbar.lengthConstraintBtn.click()
-          await cmdBar.progressCmdBar()
-          await editor.expectEditor.toContain('length001 = 7')
-
-          // wait for execute defer
-          await app.page.waitForTimeout(600)
-          await sketchIsDrawnProperly()
-
-          await app.page.keyboard.down('Meta')
-          await app.page.keyboard.press('KeyZ')
-          await app.page.keyboard.up('Meta')
-
-          await editor.expectEditor.not.toContain('length001 = 7')
-          await sketchIsDrawnProperly()
-        }
-      )
-    }
-  )
-
-  test2(
-    'can enter sketch when there is an extrude',
-    async ({ app, scene, toolbar }) => {
-      await app.initialise(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([-63.43, 193.08], sketch001)
-  |> line([168.52, 149.87], %)
-  |> line([190.29, -39.18], %)
-  |> tangentialArcTo([319.63, 129.65], %)
-  |> line([-217.65, -21.76], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-profile003 = startProfileAt([16.79, 38.24], sketch001)
-  |> angledLine([0, 182.82], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       105.71
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-profile004 = circle({
-  center = [280.45, 47.57],
-  radius = 55.26
-}, sketch001)
-extrude002 = extrude(50, profile001)
-extrude001 = extrude(5, profile003)
-`)
-      const [pointOnSegment] = scene.makeMouseHelpers(574, 207)
-
-      await pointOnSegment()
-      await toolbar.editSketch()
-      // wait for engine animation
-      await app.page.waitForTimeout(600)
-
-      await test2.step('check the sketch is still drawn properly', async () => {
-        await scene.expectPixelColor([255, 255, 255], { x: 591, y: 167 }, 15)
-        await scene.expectPixelColor([255, 255, 255], { x: 638, y: 222 }, 15)
-        await scene.expectPixelColor([255, 255, 255], { x: 756, y: 214 }, 15)
-      })
-    }
-  )
-  test2(
-    'exit new sketch without drawing anything should not be a problem',
-    async ({ app, scene, toolbar, editor, cmdBar }) => {
-      await app.initialise(`myVar = 5`)
-      const [selectXZPlane] = scene.makeMouseHelpers(650, 150)
-
-      await toolbar.startSketchPlaneSelection()
-      await selectXZPlane()
-      // timeout wait for engine animation is unavoidable
-      await app.page.waitForTimeout(600)
-
-      await editor.expectEditor.toContain(`sketch001 = startSketchOn('XZ')`)
-      await toolbar.exitSketchBtn.click()
-
-      await editor.expectEditor.not.toContain(`sketch001 = startSketchOn('XZ')`)
-
-      await test2.step(
-        "still renders code, hasn't got into a weird state",
-        async () => {
-          await editor.replaceCode(
-            'myVar = 5',
-            `myVar = 5
-  sketch001 = startSketchOn('XZ')
-  profile001 = circle({
-    center = [12.41, 3.87],
-    radius = myVar
-  }, sketch001)`
-          )
-
-          await scene.expectPixelColor([255, 255, 255], { x: 633, y: 211 }, 15)
-        }
-      )
-    }
-  )
-  test2(
-    'A sketch with only "startProfileAt" and no segments should still be able to be continued ',
-    async ({ app, scene, toolbar, editor }) => {
-      await app.initialise(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([85.19, 338.59], sketch001)
-  |> line([213.3, -94.52], %)
-  |> line([-230.09, -55.34], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-sketch002 = startSketchOn('XY')
-profile002 = startProfileAt([85.81, 52.55], sketch002)
-
-`)
-      const [startProfileAt] = scene.makeMouseHelpers(606, 184)
-      const [nextPoint] = scene.makeMouseHelpers(763, 130)
-      await app.page
-        .getByText('startProfileAt([85.81, 52.55], sketch002)')
-        .click()
-      await toolbar.editSketch()
-      // timeout wait for engine animation is unavoidable
-      await app.page.waitForTimeout(600)
-
-      // equip line tool
-      await toolbar.lineBtn.click()
-      await app.page.waitForTimeout(100)
-      await startProfileAt()
-      await app.page.waitForTimeout(100)
-      await nextPoint()
-      await editor.expectEditor.toContain(`|> line([126.05, 44.12], %)`)
-    }
-  )
-  test2(
-    'old style sketch all in one pipe (with extrude) will break up to allow users to add a new profile to the same sketch',
-    async ({ app, scene, toolbar, editor }) => {
-      await app.initialise(`thePart = startSketchOn('XZ')
-  |> startProfileAt([7.53, 10.51], %)
-  |> line([12.54, 1.83], %)
-  |> line([6.65, -6.91], %)
-  |> line([-6.31, -8.69], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-extrude001 = extrude(75, thePart)
-`)
-      const [objClick] = scene.makeMouseHelpers(565, 343)
-      const [profilePoint1] = scene.makeMouseHelpers(609, 289)
-      const [profilePoint2] = scene.makeMouseHelpers(714, 389)
-
-      await test2.step('enter sketch and setup', async () => {
-        await objClick()
-        await toolbar.editSketch()
-        // timeout wait for engine animation is unavoidable
-        await app.page.waitForTimeout(600)
-      })
-
-      await test2.step(
-        'expect code to match initial conditions still',
-        async () => {
-          await editor.expectEditor.toContain(`thePart = startSketchOn('XZ')
-    |> startProfileAt([7.53, 10.51], %)`)
-        }
-      )
-
-      await test2.step(
-        'equiping the line tool should break up the pipe expression',
-        async () => {
-          await toolbar.lineBtn.click()
-          await editor.expectEditor.toContain(
-            `sketch001 = startSketchOn('XZ')thePart = startProfileAt([7.53, 10.51], sketch001)`
-          )
-        }
-      )
-
-      await test2.step(
-        'can continue on to add a new profile to this sketch',
-        async () => {
-          await profilePoint1()
-          await editor.expectEditor.toContain(
-            `profile001 = startProfileAt([19.77, -7.08], sketch001)`
-          )
-          await profilePoint2()
-          await editor.expectEditor.toContain(`|> line([19.05, -18.14], %)`)
-        }
-      )
-    }
-  )
-})

e2e/playwright/snapshot-tests.spec.ts

@@ -446,7 +446,8 @@ test(
 
     const startXPx = 600
     await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-    code += `profile001 = startProfileAt([7.19, -9.7], sketch001)`
+    code += `
+  |> startProfileAt([7.19, -9.7], %)`
     await expect(page.locator('.cm-content')).toHaveText(code)
     await page.waitForTimeout(100)
 
@@ -468,10 +469,6 @@ test(
       .getByRole('button', { name: 'arc Tangential Arc', exact: true })
       .click()
 
-    // click to continue profile
-    await page.mouse.move(813, 392, { steps: 10 })
-    await page.waitForTimeout(100)
-
     await page.mouse.move(startXPx + PUR * 30, 500 - PUR * 20, { steps: 10 })
 
     await page.waitForTimeout(1000)
@@ -594,7 +591,8 @@ test(
       mask: [page.getByTestId('model-state-indicator')],
     })
     await expect(page.locator('.cm-content')).toHaveText(
-      `sketch001 = startSketchOn('XZ')profile001 = circle({ center = [14.44, -2.44], radius = 1 }, sketch001)`
+      `sketch001 = startSketchOn('XZ')
+  |> circle({ center = [14.44, -2.44], radius = 1 }, %)`
     )
   }
 )
@@ -638,7 +636,8 @@ test.describe(
 
       const startXPx = 600
       await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-      code += `profile001 = startProfileAt([7.19, -9.7], sketch001)`
+      code += `
+  |> startProfileAt([7.19, -9.7], %)`
       await expect(u.codeLocator).toHaveText(code)
       await page.waitForTimeout(100)
 
@@ -656,10 +655,6 @@ test.describe(
         .click()
       await page.waitForTimeout(100)
 
-      // click to continue profile
-      await page.mouse.click(813, 392)
-      await page.waitForTimeout(100)
-
       await page.mouse.click(startXPx + PUR * 30, 500 - PUR * 20)
 
       code += `
@@ -746,7 +741,8 @@ test.describe(
 
       const startXPx = 600
       await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-      code += `profile001 = startProfileAt([182.59, -246.32], sketch001)`
+      code += `
+  |> startProfileAt([182.59, -246.32], %)`
       await expect(u.codeLocator).toHaveText(code)
       await page.waitForTimeout(100)
 
@@ -764,10 +760,6 @@ test.describe(
         .click()
       await page.waitForTimeout(100)
 
-      // click to continue profile
-      await page.mouse.click(813, 392)
-      await page.waitForTimeout(100)
-
       await page.mouse.click(startXPx + PUR * 30, 500 - PUR * 20)
 
       code += `
@@ -958,75 +950,7 @@ test(
 
 test.describe('Grid visibility', { tag: '@snapshot' }, () => {
   // FIXME: Skip on macos its being weird.
-  // test.skip(process.platform === 'darwin', 'Skip on macos')
-
-  test('Grid turned off to on via command bar', async ({ page }) => {
-    const u = await getUtils(page)
-    const stream = page.getByTestId('stream')
-    const mask = [
-      page.locator('#app-header'),
-      page.locator('#sidebar-top-ribbon'),
-      page.locator('#sidebar-bottom-ribbon'),
-    ]
-
-    await page.setViewportSize({ width: 1200, height: 500 })
-    await page.goto('/')
-    await u.waitForAuthSkipAppStart()
-
-    await u.openDebugPanel()
-    // wait for execution done
-    await expect(
-      page.locator('[data-message-type="execution-done"]')
-    ).toHaveCount(1)
-    await u.closeDebugPanel()
-    await u.closeKclCodePanel()
-    // TODO: Find a way to truly know that the objects have finished
-    // rendering, because an execution-done message is not sufficient.
-    await page.waitForTimeout(1000)
-
-    // Open the command bar.
-    await page
-      .getByRole('button', { name: 'Commands', exact: false })
-      .or(page.getByRole('button', { name: '⌘K' }))
-      .click()
-    const commandName = 'show scale grid'
-    const commandOption = page.getByRole('option', {
-      name: commandName,
-      exact: false,
-    })
-    const cmdSearchBar = page.getByPlaceholder('Search commands')
-    // This selector changes after we set the setting
-    await cmdSearchBar.fill(commandName)
-    await expect(commandOption).toBeVisible()
-    await commandOption.click()
-
-    const toggleInput = page.getByPlaceholder('Off')
-    await expect(toggleInput).toBeVisible()
-    await expect(toggleInput).toBeFocused()
-
-    // Select On
-    await page.keyboard.press('ArrowDown')
-    await expect(page.getByRole('option', { name: 'Off' })).toHaveAttribute(
-      'data-headlessui-state',
-      'active selected'
-    )
-    await page.keyboard.press('ArrowUp')
-    await expect(page.getByRole('option', { name: 'On' })).toHaveAttribute(
-      'data-headlessui-state',
-      'active'
-    )
-    await page.keyboard.press('Enter')
-
-    // Check the toast appeared
-    await expect(
-      page.getByText(`Set show scale grid to "true" as a user default`)
-    ).toBeVisible()
-
-    await expect(stream).toHaveScreenshot({
-      maxDiffPixels: 100,
-      mask,
-    })
-  })
+  test.skip(process.platform === 'darwin', 'Skip on macos')
 
   test('Grid turned off', async ({ page }) => {
     const u = await getUtils(page)
@@ -1172,109 +1096,3 @@ test.fixme('theme persists', async ({ page, context }) => {
     maxDiffPixels: 100,
   })
 })
-
-test.describe('code color goober', { tag: '@snapshot' }, () => {
-  test('code color goober', async ({ page, context }) => {
-    const u = await getUtils(page)
-    await context.addInitScript(async () => {
-      localStorage.setItem(
-        'persistCode',
-        `// Create a pipe using a sweep.
-
-// Create a path for the sweep.
-sweepPath = startSketchOn('XZ')
-  |> startProfileAt([0.05, 0.05], %)
-  |> line([0, 7], %)
-  |> tangentialArc({ offset = 90, radius = 5 }, %)
-  |> line([-3, 0], %)
-  |> tangentialArc({ offset = -90, radius = 5 }, %)
-  |> line([0, 7], %)
-
-sweepSketch = startSketchOn('XY')
-  |> startProfileAt([2, 0], %)
-  |> arc({
-       angleEnd = 360,
-       angleStart = 0,
-       radius = 2
-     }, %)
-  |> sweep({
-    path = sweepPath,
-  }, %)
-  |> appearance({
-       color = "#bb00ff",
-       metalness = 90,
-       roughness = 90
-     }, %)
-`
-      )
-    })
-
-    await page.setViewportSize({ width: 1200, height: 1000 })
-
-    await u.waitForAuthSkipAppStart()
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.clearAndCloseDebugPanel()
-
-    await expect(page, 'expect small color widget').toHaveScreenshot({
-      maxDiffPixels: 100,
-    })
-  })
-
-  test('code color goober opening window', async ({ page, context }) => {
-    const u = await getUtils(page)
-    await context.addInitScript(async () => {
-      localStorage.setItem(
-        'persistCode',
-        `// Create a pipe using a sweep.
-
-// Create a path for the sweep.
-sweepPath = startSketchOn('XZ')
-  |> startProfileAt([0.05, 0.05], %)
-  |> line([0, 7], %)
-  |> tangentialArc({ offset = 90, radius = 5 }, %)
-  |> line([-3, 0], %)
-  |> tangentialArc({ offset = -90, radius = 5 }, %)
-  |> line([0, 7], %)
-
-sweepSketch = startSketchOn('XY')
-  |> startProfileAt([2, 0], %)
-  |> arc({
-       angleEnd = 360,
-       angleStart = 0,
-       radius = 2
-     }, %)
-  |> sweep({
-    path = sweepPath,
-  }, %)
-  |> appearance({
-       color = "#bb00ff",
-       metalness = 90,
-       roughness = 90
-     }, %)
-`
-      )
-    })
-
-    await page.setViewportSize({ width: 1200, height: 1000 })
-
-    await u.waitForAuthSkipAppStart()
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.clearAndCloseDebugPanel()
-
-    await expect(page.locator('.cm-css-color-picker-wrapper')).toBeVisible()
-
-    // Click the color widget
-    await page.locator('.cm-css-color-picker-wrapper input').click()
-
-    await expect(
-      page,
-      'expect small color widget to have window open'
-    ).toHaveScreenshot({
-      maxDiffPixels: 100,
-    })
-  })
-})

e2e/playwright/storageStates.ts

@@ -14,7 +14,7 @@ export const TEST_SETTINGS = {
   },
   modeling: {
     defaultUnit: 'in',
-    mouseControls: 'Zoo',
+    mouseControls: 'KittyCAD',
     cameraProjection: 'perspective',
     showDebugPanel: true,
   },

e2e/playwright/test-network-and-connection-issues.spec.ts

@@ -1,8 +1,6 @@
 import { test, expect } from '@playwright/test'
 
 import { commonPoints, getUtils, setup, tearDown } from './test-utils'
-import { uuidv4 } from 'lib/utils'
-import { EngineCommand } from 'lang/std/artifactGraph'
 
 test.beforeEach(async ({ context, page }, testInfo) => {
   await setup(context, page, testInfo)
@@ -132,16 +130,17 @@ test.describe('Test network and connection issues', () => {
 
     const startXPx = 600
     await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-    await expect(page.locator('.cm-content')).toHaveText(
-      `sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)`
-    )
+    await expect(page.locator('.cm-content'))
+      .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)`)
     await page.waitForTimeout(100)
 
     await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 10)
     await page.waitForTimeout(100)
 
     await expect(page.locator('.cm-content'))
-      .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)
+      .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)
     |> xLine(${commonPoints.num1}, %)`)
 
     // Expect the network to be up
@@ -189,9 +188,7 @@ test.describe('Test network and connection issues', () => {
     await page.mouse.click(100, 100)
 
     // select a line
-    await page
-      .getByText(`startProfileAt(${commonPoints.startAt}, sketch001)`)
-      .click()
+    await page.getByText(`startProfileAt(${commonPoints.startAt}, %)`).click()
 
     // enter sketch again
     await u.doAndWaitForCmd(
@@ -205,36 +202,11 @@ test.describe('Test network and connection issues', () => {
 
     await page.waitForTimeout(150)
 
-    const camCommand: EngineCommand = {
-      type: 'modeling_cmd_req',
-      cmd_id: uuidv4(),
-      cmd: {
-        type: 'default_camera_look_at',
-        center: { x: 109, y: 0, z: -152 },
-        vantage: { x: 115, y: -505, z: -152 },
-        up: { x: 0, y: 0, z: 1 },
-      },
-    }
-    const updateCamCommand: EngineCommand = {
-      type: 'modeling_cmd_req',
-      cmd_id: uuidv4(),
-      cmd: {
-        type: 'default_camera_get_settings',
-      },
-    }
-    await u.sendCustomCmd(camCommand)
-    await page.waitForTimeout(100)
-    await u.sendCustomCmd(updateCamCommand)
-    await page.waitForTimeout(100)
-
-    // click to continue profile
-    await page.mouse.click(1007, 400)
-    await page.waitForTimeout(100)
     // Ensure we can continue sketching
     await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 20)
     await expect.poll(u.normalisedEditorCode)
       .toBe(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([12.34, -12.34], sketch001)
+  |> startProfileAt([12.34, -12.34], %)
   |> xLine(12.34, %)
   |> line([-12.34, 12.34], %)
 
@@ -244,7 +216,7 @@ profile001 = startProfileAt([12.34, -12.34], sketch001)
 
     await expect.poll(u.normalisedEditorCode)
       .toBe(`sketch001 = startSketchOn('XZ')
-profile001 = startProfileAt([12.34, -12.34], sketch001)
+  |> startProfileAt([12.34, -12.34], %)
   |> xLine(12.34, %)
   |> line([-12.34, 12.34], %)
   |> xLine(-12.34, %)

e2e/playwright/testing-camera-movement.spec.ts

@@ -479,26 +479,4 @@ test.describe('Testing Camera Movement', () => {
       })
     }
   })
-
-  test('Right-click opens context menu when not dragged', async ({ page }) => {
-    const u = await getUtils(page)
-    await u.waitForAuthSkipAppStart()
-
-    await test.step(`The menu should not show if we drag the mouse`, async () => {
-      await page.mouse.move(900, 200)
-      await page.mouse.down({ button: 'right' })
-      await page.mouse.move(900, 300)
-      await page.mouse.up({ button: 'right' })
-
-      await expect(page.getByTestId('view-controls-menu')).not.toBeVisible()
-    })
-
-    await test.step(`The menu should show if we don't drag the mouse`, async () => {
-      await page.mouse.move(900, 200)
-      await page.mouse.down({ button: 'right' })
-      await page.mouse.up({ button: 'right' })
-
-      await expect(page.getByTestId('view-controls-menu')).toBeVisible()
-    })
-  })
 })

e2e/playwright/testing-constraints.spec.ts

@@ -17,26 +17,16 @@ test.describe('Testing constraints', () => {
       localStorage.setItem(
         'persistCode',
         `sketch001 = startSketchOn('XY')
-  |> startProfileAt([-10, -10], %)
-  |> line([20, 0], %)
-  |> line([0, 20], %)
-  |> xLine(-20, %)
-`
+    |> startProfileAt([-10, -10], %)
+    |> line([20, 0], %)
+    |> line([0, 20], %)
+    |> xLine(-20, %)
+  `
       )
     })
 
     const u = await getUtils(page)
-    // constants and locators
-    const lengthValue = {
-      old: '20',
-      new: '25',
-    }
-    const cmdBarKclInput = page
-      .getByTestId('cmd-bar-arg-value')
-      .getByRole('textbox')
-    const cmdBarSubmitButton = page.getByRole('button', {
-      name: 'arrow right Continue',
-    })
+    const PUR = 400 / 37.5 //pixeltoUnitRatio
     await page.setViewportSize({ width: 1200, height: 500 })
 
     await u.waitForAuthSkipAppStart()
@@ -46,26 +36,26 @@ test.describe('Testing constraints', () => {
     await u.closeDebugPanel()
 
     // Click the line of code for line.
-    // TODO remove this and reinstate `await topHorzSegmentClick()`
-    await page.getByText(`line([0, ${lengthValue.old}], %)`).click()
+    await page.getByText(`line([0, 20], %)`).click() // TODO remove this and reinstate // await topHorzSegmentClick()
     await page.waitForTimeout(100)
 
     // enter sketch again
     await page.getByRole('button', { name: 'Edit Sketch' }).click()
     await page.waitForTimeout(500) // wait for animation
+
+    const startXPx = 500
+    await page.mouse.move(startXPx + PUR * 15, 250 - PUR * 10)
+    await page.keyboard.down('Shift')
+    await page.mouse.click(834, 244)
+    await page.keyboard.up('Shift')
+
     await page
       .getByRole('button', { name: 'dimension Length', exact: true })
       .click()
-    await expect(cmdBarKclInput).toHaveText('20')
-    await cmdBarKclInput.fill(lengthValue.new)
-    await expect(
-      page.getByText(`Can't calculate`),
-      `Something went wrong with the KCL expression evaluation`
-    ).not.toBeVisible()
-    await cmdBarSubmitButton.click()
+    await page.getByText('Add constraining value').click()
 
     await expect(page.locator('.cm-content')).toHaveText(
-      `length001 = ${lengthValue.new}sketch001 = startSketchOn('XY')  |> startProfileAt([-10, -10], %)  |> line([20, 0], %)  |> angledLine([90, length001], %)  |> xLine(-20, %)`
+      `length001 = 20sketch001 = startSketchOn('XY')  |> startProfileAt([-10, -10], %)  |> line([20, 0], %)  |> angledLine([90, length001], %)  |> xLine(-20, %)`
     )
 
     // Make sure we didn't pop out of sketch mode.
@@ -76,6 +66,7 @@ test.describe('Testing constraints', () => {
     await page.waitForTimeout(500) // wait for animation
 
     // Exit sketch
+    await page.mouse.move(startXPx + PUR * 15, 250 - PUR * 10)
     await page.keyboard.press('Escape')
     await expect(
       page.getByRole('button', { name: 'Exit Sketch' })
@@ -533,7 +524,7 @@ part002 = startSketchOn('XZ')
       })
     }
   })
-  test.describe('Test Angle constraint single selection', () => {
+  test.describe('Test Angle/Length constraint single selection', () => {
     const cases = [
       {
         testName: 'Angle - Add variable',
@@ -547,6 +538,18 @@ part002 = startSketchOn('XZ')
         constraint: 'angle',
         value: '83, 78.33',
       },
+      {
+        testName: 'Length - Add variable',
+        addVariable: true,
+        constraint: 'length',
+        value: '83, length001',
+      },
+      {
+        testName: 'Length - No variable',
+        addVariable: false,
+        constraint: 'length',
+        value: '83, 78.33',
+      },
     ] as const
     for (const { testName, addVariable, value, constraint } of cases) {
       test(`${testName}`, async ({ page }) => {
@@ -605,90 +608,6 @@ part002 = startSketchOn('XZ')
       })
     }
   })
-  test.describe('Test Length constraint single selection', () => {
-    const cases = [
-      {
-        testName: 'Length - Add variable',
-        addVariable: true,
-        constraint: 'length',
-        value: '83, length001',
-      },
-      {
-        testName: 'Length - No variable',
-        addVariable: false,
-        constraint: 'length',
-        value: '83, 78.33',
-      },
-    ] as const
-    for (const { testName, addVariable, value, constraint } of cases) {
-      test(`${testName}`, async ({ page }) => {
-        // constants and locators
-        const cmdBarKclInput = page
-          .getByTestId('cmd-bar-arg-value')
-          .getByRole('textbox')
-        const cmdBarKclVariableNameInput =
-          page.getByPlaceholder('Variable name')
-        const cmdBarSubmitButton = page.getByRole('button', {
-          name: 'arrow right Continue',
-        })
-
-        await page.addInitScript(async () => {
-          localStorage.setItem(
-            'persistCode',
-            `yo = 5
-part001 = startSketchOn('XZ')
-  |> startProfileAt([-7.54, -26.74], %)
-  |> line([74.36, 130.4], %)
-  |> line([78.92, -120.11], %)
-  |> line([9.16, 77.79], %)
-  |> line([51.19, 48.97], %)
-part002 = startSketchOn('XZ')
-  |> startProfileAt([299.05, 231.45], %)
-  |> xLine(-425.34, %, $seg_what)
-  |> yLine(-264.06, %)
-  |> xLine(segLen(seg_what), %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)`
-          )
-        })
-        const u = await getUtils(page)
-        await page.setViewportSize({ width: 1200, height: 500 })
-
-        await u.waitForAuthSkipAppStart()
-
-        await page.getByText('line([74.36, 130.4], %)').click()
-        await page.getByRole('button', { name: 'Edit Sketch' }).click()
-
-        const line3 = await u.getSegmentBodyCoords(
-          `[data-overlay-index="${2}"]`
-        )
-
-        await page.mouse.click(line3.x, line3.y)
-        await page
-          .getByRole('button', {
-            name: 'Length: open menu',
-          })
-          .click()
-        await page.getByTestId('dropdown-constraint-' + constraint).click()
-
-        if (!addVariable) {
-          await test.step(`Clear the variable input`, async () => {
-            await cmdBarKclVariableNameInput.clear()
-            await cmdBarKclVariableNameInput.press('Backspace')
-          })
-        }
-        await expect(cmdBarKclInput).toHaveText('78.33')
-        await cmdBarSubmitButton.click()
-
-        const changedCode = `|> angledLine([${value}], %)`
-        await expect(page.locator('.cm-content')).toContainText(changedCode)
-        // checking active assures the cursor is where it should be
-        await expect(page.locator('.cm-activeLine')).toHaveText(changedCode)
-
-        // checking the count of the overlays is a good proxy check that the client sketch scene is in a good state
-        await expect(page.getByTestId('segment-overlay')).toHaveCount(4)
-      })
-    }
-  })
   test.describe('Many segments - no modal constraints', () => {
     const cases = [
       {
@@ -949,15 +868,6 @@ part002 = startSketchOn('XZ')
   |> line([3.13, -2.4], %)`
       )
     })
-
-    // constants and locators
-    const cmdBarKclInput = page
-      .getByTestId('cmd-bar-arg-value')
-      .getByRole('textbox')
-    const cmdBarSubmitButton = page.getByRole('button', {
-      name: 'arrow right Continue',
-    })
-
     const u = await getUtils(page)
     await page.setViewportSize({ width: 1200, height: 500 })
 
@@ -1018,8 +928,8 @@ part002 = startSketchOn('XZ')
     // await page.getByRole('button', { name: 'length', exact: true }).click()
     await page.getByTestId('dropdown-constraint-length').click()
 
-    await cmdBarKclInput.fill('10')
-    await cmdBarSubmitButton.click()
+    await page.getByLabel('length Value').fill('10')
+    await page.getByRole('button', { name: 'Add constraining value' }).click()
 
     activeLinesContent = await page.locator('.cm-activeLine').all()
     await expect(activeLinesContent[0]).toHaveText(`|> xLine(length001, %)`)

e2e/playwright/testing-segment-overlays.spec.ts

@@ -91,14 +91,7 @@ test.describe('Testing segment overlays', () => {
           await page.getByTestId('constraint-symbol-popover').count()
         ).toBeGreaterThan(0)
         await unconstrainedLocator.click()
-        await expect(
-          page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
-        ).toBeFocused()
-        await page
-          .getByRole('button', {
-            name: 'arrow right Continue',
-          })
-          .click()
+        await page.getByText('Add variable').click()
         await expect(page.locator('.cm-content')).toContainText(expectFinal)
       }
 
@@ -158,14 +151,7 @@ test.describe('Testing segment overlays', () => {
           await page.getByTestId('constraint-symbol-popover').count()
         ).toBeGreaterThan(0)
         await unconstrainedLocator.click()
-        await expect(
-          page.getByTestId('cmd-bar-arg-value').getByRole('textbox')
-        ).toBeFocused()
-        await page
-          .getByRole('button', {
-            name: 'arrow right Continue',
-          })
-          .click()
+        await page.getByText('Add variable').click()
         await expect(page.locator('.cm-content')).toContainText(
           expectAfterUnconstrained
         )

e2e/playwright/testing-selections.spec.ts

@@ -77,31 +77,30 @@ test.describe('Testing selections', () => {
       const startXPx = 600
       await u.closeDebugPanel()
       await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-      await expect(page.locator('.cm-content')).toHaveText(
-        `sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)`
-      )
+      await expect(page.locator('.cm-content'))
+        .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)`)
 
       await page.waitForTimeout(100)
       await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 10)
 
       await expect(page.locator('.cm-content'))
-        .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${commonPoints.startAt}, sketch001)
+        .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)
     |> xLine(${commonPoints.num1}, %)`)
 
       await page.waitForTimeout(100)
       await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 20)
       await expect(page.locator('.cm-content'))
-        .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${
-        commonPoints.startAt
-      }, sketch001)
+        .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)
     |> xLine(${commonPoints.num1}, %)
     |> yLine(${commonPoints.num1 + 0.01}, %)`)
       await page.waitForTimeout(100)
       await page.mouse.click(startXPx, 500 - PUR * 20)
       await expect(page.locator('.cm-content'))
-        .toHaveText(`sketch001 = startSketchOn('XZ')profile001 = startProfileAt(${
-        commonPoints.startAt
-      }, sketch001)
+        .toHaveText(`sketch001 = startSketchOn('XZ')
+    |> startProfileAt(${commonPoints.startAt}, %)
     |> xLine(${commonPoints.num1}, %)
     |> yLine(${commonPoints.num1 + 0.01}, %)
     |> xLine(${commonPoints.num2 * -1}, %)`)
@@ -331,28 +330,6 @@ part009 = startSketchOn('XY')
   |> angledLineToX({ angle = 60, to = pipeLargeDia }, %)
   |> close(%)
 rev = revolve({ axis = 'y' }, part009)
-sketch006 = startSketchOn('XY')
-profile001 = circle({
-  center = [42.91, -70.42],
-  radius = 17.96
-}, sketch006)
-profile002 = startProfileAt([86.92, -63.81], sketch006)
-  |> angledLine([0, 63.81], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       17.05
-     ], %)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-profile003 = startProfileAt([40.16, -120.48], sketch006)
-  |> line([26.95, 24.21], %)
-  |> line([20.91, -28.61], %)
-  |> line([32.46, 18.71], %)
-
 `
       )
     }, KCL_DEFAULT_LENGTH)
@@ -385,10 +362,9 @@ profile003 = startProfileAt([40.16, -120.48], sketch006)
     })
     await page.waitForTimeout(100)
 
-    const revolve = { x: 635, y: 253 }
+    const revolve = { x: 646, y: 248 }
     const parentExtrude = { x: 915, y: 133 }
     const solid2d = { x: 770, y: 167 }
-    const individualProfile = { x: 694, y: 432 }
 
     // DELETE REVOLVE
     await page.mouse.click(revolve.x, revolve.y)
@@ -454,20 +430,6 @@ profile003 = startProfileAt([40.16, -120.48], sketch006)
     await u.expectCmdLog('[data-message-type="execution-done"]', 10_000)
     await page.waitForTimeout(200)
     await expect(u.codeLocator).not.toContainText(`sketch005 = startSketchOn({`)
-
-    // Delete a single profile
-    await page.mouse.click(individualProfile.x, individualProfile.y)
-    await page.waitForTimeout(100)
-    const codeToBeDeletedSnippet =
-      'profile003 = startProfileAt([40.16, -120.48], sketch006)'
-    await expect(page.locator('.cm-activeLine')).toHaveText(
-      '  |> line([20.91, -28.61], %)'
-    )
-    await u.clearCommandLogs()
-    await page.keyboard.press('Backspace')
-    await u.expectCmdLog('[data-message-type="execution-done"]', 10_000)
-    await page.waitForTimeout(200)
-    await expect(u.codeLocator).not.toContainText(codeToBeDeletedSnippet)
   })
   test("Deleting solid that the AST mod can't handle results in a toast message", async ({
     page,
@@ -1296,15 +1258,12 @@ extrude001 = extrude(50, sketch001)
 
     await page.waitForTimeout(600)
 
-    const firstClickCoords = { x: 650, y: 200 } as const
     // Place a point because the line tool will exit if no points are pressed
-    await page.mouse.click(firstClickCoords.x, firstClickCoords.y)
+    await page.mouse.click(650, 200)
     await page.waitForTimeout(600)
 
     // Code before exiting the tool
-    let previousCodeContent = (
-      await page.locator('.cm-content').innerText()
-    ).replace(/\s+/g, '')
+    let previousCodeContent = await page.locator('.cm-content').innerText()
 
     // deselect the line tool by clicking it
     await page.getByRole('button', { name: 'line Line', exact: true }).click()
@@ -1316,23 +1275,14 @@ extrude001 = extrude(50, sketch001)
     await page.mouse.click(750, 200)
     await page.waitForTimeout(100)
 
-    await expect
-      .poll(async () => {
-        let str = await page.locator('.cm-content').innerText()
-        str = str.replace(/\s+/g, '')
-        return str
-      })
-      .toBe(previousCodeContent)
+    // expect no change
+    await expect(page.locator('.cm-content')).toHaveText(previousCodeContent)
 
     // select line tool again
     await page.getByRole('button', { name: 'line Line', exact: true }).click()
 
     await u.closeDebugPanel()
 
-    // Click to continue profile
-    await page.mouse.click(firstClickCoords.x, firstClickCoords.y)
-    await page.waitForTimeout(100)
-
     // line tool should work as expected again
     await page.mouse.click(700, 200)
     await expect(page.locator('.cm-content')).not.toHaveText(

e2e/playwright/various.spec.ts

@@ -224,13 +224,8 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   // Draw a line
   await page.mouse.move(700, 200, { steps: 5 })
   await page.mouse.click(700, 200)
-
-  const secondMousePosition = { x: 800, y: 250 }
-
-  await page.mouse.move(secondMousePosition.x, secondMousePosition.y, {
-    steps: 5,
-  })
-  await page.mouse.click(secondMousePosition.x, secondMousePosition.y)
+  await page.mouse.move(800, 250, { steps: 5 })
+  await page.mouse.click(800, 250)
   // Unequip line tool
   await page.keyboard.press('Escape')
   // Make sure we didn't pop out of sketch mode.
@@ -239,17 +234,9 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   // Equip arc tool
   await page.keyboard.press('a')
   await expect(arcButton).toHaveAttribute('aria-pressed', 'true')
-
-  // click in the same position again to continue the profile
-  await page.mouse.move(secondMousePosition.x, secondMousePosition.y, {
-    steps: 5,
-  })
-  await page.mouse.click(secondMousePosition.x, secondMousePosition.y)
-
   await page.mouse.move(1000, 100, { steps: 5 })
   await page.mouse.click(1000, 100)
   await page.keyboard.press('Escape')
-  await expect(arcButton).toHaveAttribute('aria-pressed', 'false')
   await page.keyboard.press('l')
   await expect(lineButton).toHaveAttribute('aria-pressed', 'true')
 
@@ -550,9 +537,9 @@ test('Sketch on face', async ({ page }) => {
 
   await expect.poll(u.normalisedEditorCode).toContain(
     u.normalisedCode(`sketch002 = startSketchOn(extrude001, seg01)
-profile001 = startProfileAt([-12.88, 6.66], sketch002)
-  |> line([2.71, -0.22], %)
-  |> line([-2.87, -1.38], %)
+  |> startProfileAt([-12.94, 6.6], %)
+  |> line([2.45, -0.2], %)
+  |> line([-2.6, -1.25], %)
   |> lineTo([profileStartX(%), profileStartY(%)], %)
   |> close(%)`)
   )
@@ -567,7 +554,8 @@ profile001 = startProfileAt([-12.88, 6.66], sketch002)
   await page.getByText('startProfileAt([-12').click()
   await expect(page.getByRole('button', { name: 'Edit Sketch' })).toBeVisible()
   await page.getByRole('button', { name: 'Edit Sketch' }).click()
-  await page.waitForTimeout(500)
+  await page.waitForTimeout(400)
+  await page.waitForTimeout(150)
   await page.setViewportSize({ width: 1200, height: 1200 })
   await u.openAndClearDebugPanel()
   await u.updateCamPosition([452, -152, 1166])

forge.config.ts

@@ -1,9 +1,20 @@
 import type { ForgeConfig } from '@electron-forge/shared-types'
+import { MakerSquirrel } from '@electron-forge/maker-squirrel'
+import { MakerZIP } from '@electron-forge/maker-zip'
+import { MakerDeb } from '@electron-forge/maker-deb'
+import { MakerRpm } from '@electron-forge/maker-rpm'
 import { VitePlugin } from '@electron-forge/plugin-vite'
+import { MakerWix, MakerWixConfig } from '@electron-forge/maker-wix'
 import { FusesPlugin } from '@electron-forge/plugin-fuses'
 import { FuseV1Options, FuseVersion } from '@electron/fuses'
 import path from 'path'
 
+interface ExtendedMakerWixConfig extends MakerWixConfig {
+  // see https://github.com/electron/forge/issues/3673
+  // this is an undocumented property of electron-wix-msi
+  associateExtensions?: string
+}
+
 const rootDir = process.cwd()
 
 const config: ForgeConfig = {
@@ -28,7 +39,26 @@ const config: ForgeConfig = {
     extendInfo: 'Info.plist', // Information for file associations.
   },
   rebuildConfig: {},
-  makers: [],
+  makers: [
+    new MakerSquirrel({
+      setupIcon: path.resolve(rootDir, 'assets', 'icon.ico'),
+    }),
+    new MakerWix({
+      icon: path.resolve(rootDir, 'assets', 'icon.ico'),
+      associateExtensions: 'kcl',
+    } as ExtendedMakerWixConfig),
+    new MakerZIP({}, ['darwin']),
+    new MakerRpm({
+      options: {
+        icon: path.resolve(rootDir, 'assets', 'icon.png'),
+      },
+    }),
+    new MakerDeb({
+      options: {
+        icon: path.resolve(rootDir, 'assets', 'icon.png'),
+      },
+    }),
+  ],
   plugins: [
     new VitePlugin({
       // `build` can specify multiple entry builds, which can be Main process, Preload scripts, Worker process, etc.

package.json

@@ -39,6 +39,7 @@
     "chokidar": "^4.0.1",
     "codemirror": "^6.0.1",
     "decamelize": "^6.0.0",
+    "electron-squirrel-startup": "^1.0.1",
     "electron-updater": "6.3.0",
     "fuse.js": "^7.0.0",
     "html2canvas-pro": "^1.5.8",
@@ -68,7 +69,7 @@
     "yargs": "^17.7.2"
   },
   "scripts": {
-    "start": "vite --port=3000 --host=0.0.0.0",
+    "start": "vite",
     "start:prod": "vite preview --port=3000",
     "serve": "vite serve --port=3000",
     "build": "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && source \"$HOME/.cargo/env\" && curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh -s -- -y && yarn build:wasm && vite build",
@@ -103,6 +104,8 @@
     "generate:machine-api": "npx openapi-typescript ./openapi/machine-api.json -o src/lib/machine-api.d.ts",
     "tron:start": "electron-forge start",
     "tron:package": "electron-forge package",
+    "tron:make": "electron-forge make",
+    "tron:publish": "electron-forge publish",
     "tron:test": "NODE_ENV=development yarn playwright test --config=playwright.electron.config.ts --grep=@electron",
     "tronb:vite": "vite build -c vite.main.config.ts && vite build -c vite.preload.config.ts && vite build -c vite.renderer.config.ts",
     "tronb:package": "electron-builder --config electron-builder.yml",
@@ -145,10 +148,17 @@
   "devDependencies": {
     "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
     "@babel/preset-env": "^7.25.4",
-    "@electron-forge/cli": "7.4.0",
-    "@electron-forge/plugin-fuses": "7.4.0",
-    "@electron-forge/plugin-vite": "7.4.0",
-    "@electron/fuses": "1.8.0",
+    "@electron-forge/cli": "^7.4.0",
+    "@electron-forge/maker-deb": "^7.4.0",
+    "@electron-forge/maker-rpm": "^7.4.0",
+    "@electron-forge/maker-squirrel": "^7.4.0",
+    "@electron-forge/maker-wix": "^7.5.0",
+    "@electron-forge/maker-zip": "^7.5.0",
+    "@electron-forge/plugin-auto-unpack-natives": "^7.4.0",
+    "@electron-forge/plugin-fuses": "^7.4.0",
+    "@electron-forge/plugin-vite": "^7.4.0",
+    "@electron/fuses": "^1.8.0",
+    "@electron/rebuild": "^3.6.0",
     "@iarna/toml": "^2.2.5",
     "@lezer/generator": "^1.7.1",
     "@nabla/vite-plugin-eslint": "^2.0.5",
@@ -178,9 +188,9 @@
     "@xstate/cli": "^0.5.17",
     "autoprefixer": "^10.4.19",
     "d3-force": "^3.0.0",
-    "electron": "32.1.2",
-    "electron-builder": "24.13.3",
-    "electron-notarize": "1.2.2",
+    "electron": "^32.1.2",
+    "electron-builder": "^24.13.3",
+    "electron-notarize": "^1.2.2",
     "eslint": "^8.0.1",
     "eslint-config-react-app": "^7.0.1",
     "eslint-plugin-css-modules": "^2.12.0",

src/Toolbar.tsx

@@ -6,6 +6,7 @@ import { useCommandsContext } from 'hooks/useCommandsContext'
 import { useNetworkContext } from 'hooks/useNetworkContext'
 import { NetworkHealthState } from 'hooks/useNetworkStatus'
 import { ActionButton } from 'components/ActionButton'
+import { isSingleCursorInPipe } from 'lang/queryAst'
 import { useKclContext } from 'lang/KclProvider'
 import { ActionButtonDropdown } from 'components/ActionButtonDropdown'
 import { useHotkeys } from 'react-hotkeys-hook'
@@ -21,7 +22,6 @@ import {
 } from 'lib/toolbar'
 import { isDesktop } from 'lib/isDesktop'
 import { openExternalBrowserIfDesktop } from 'lib/openWindow'
-import { isCursorInFunctionDefinition } from 'lang/queryAst'
 
 export function Toolbar({
   className = '',
@@ -38,12 +38,7 @@ export function Toolbar({
     '!border-transparent hover:!border-chalkboard-20 dark:enabled:hover:!border-primary pressed:!border-primary ui-open:!border-primary'
 
   const sketchPathId = useMemo(() => {
-    if (
-      isCursorInFunctionDefinition(
-        kclManager.ast,
-        context.selectionRanges.graphSelections[0]
-      )
-    )
+    if (!isSingleCursorInPipe(context.selectionRanges, kclManager.ast))
       return false
     return isCursorInSketchCommandRange(
       engineCommandManager.artifactGraph,

src/clientSideScene/CameraControls.ts

@@ -105,7 +105,7 @@ export class CameraControls {
   pendingZoom: number | null = null
   pendingRotation: Vector2 | null = null
   pendingPan: Vector2 | null = null
-  interactionGuards: MouseGuard = cameraMouseDragGuards.Zoo
+  interactionGuards: MouseGuard = cameraMouseDragGuards.KittyCAD
   isFovAnimationInProgress = false
   perspectiveFovBeforeOrtho = 45
   get isPerspective() {

src/clientSideScene/ClientSideSceneComp.tsx

@@ -433,8 +433,6 @@ export async function deleteSegment({
   if (!sketchDetails) return
   await sceneEntitiesManager.updateAstAndRejigSketch(
     pathToNode,
-    sketchDetails.sketchNodePaths,
-    sketchDetails.planeNodePath,
     modifiedAst,
     sketchDetails.zAxis,
     sketchDetails.yAxis,
@@ -507,8 +505,7 @@ const ConstraintSymbol = ({
   constrainInfo: ConstrainInfo
   verticalPosition: 'top' | 'bottom'
 }) => {
-  const { commandBarSend } = useCommandsContext()
-  const { context } = useModelingContext()
+  const { context, send } = useModelingContext()
   const varNameMap: {
     [key in ConstrainInfo['type']]: {
       varName: string
@@ -627,18 +624,11 @@ const ConstraintSymbol = ({
         // disabled={implicitDesc} TODO why does this change styles that are hard to override?
         onClick={toSync(async () => {
           if (!isConstrained) {
-            commandBarSend({
-              type: 'Find and select command',
+            send({
+              type: 'Convert to variable',
               data: {
-                name: 'Constrain with named value',
-                groupId: 'modeling',
-                argDefaultValues: {
-                  currentValue: {
-                    pathToNode,
-                    variableName: varName,
-                    valueText: value,
-                  },
-                },
+                pathToNode,
+                variableName: varName,
               },
             })
           } else if (isConstrained) {

src/clientSideScene/segments.ts

@@ -691,21 +691,19 @@ export function createProfileStartHandle({
   scale = 1,
   theme,
   isSelected,
-  size = 12,
   ...rest
 }: {
   from: Coords2d
   scale?: number
   theme: Themes
   isSelected?: boolean
-  size?: number
 } & (
   | { isDraft: true }
   | { isDraft: false; id: string; pathToNode: PathToNode }
 )) {
   const group = new Group()
 
-  const geometry = new BoxGeometry(size, size, size) // in pixels scaled later
+  const geometry = new BoxGeometry(12, 12, 12) // in pixels scaled later
   const baseColor = getThemeColorForThreeJs(theme)
   const color = isSelected ? 0x0000ff : baseColor
   const body = new MeshBasicMaterial({ color })

src/components/CommandBar/CommandBarKclInput.tsx

@@ -8,16 +8,11 @@ import { getSystemTheme } from 'lib/theme'
 import { useCalculateKclExpression } from 'lib/useCalculateKclExpression'
 import { roundOff } from 'lib/utils'
 import { varMentions } from 'lib/varCompletionExtension'
-import { useEffect, useMemo, useRef, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
 import { useHotkeys } from 'react-hotkeys-hook'
 import styles from './CommandBarKclInput.module.css'
 import { createIdentifier, createVariableDeclaration } from 'lang/modifyAst'
 import { useCodeMirror } from 'components/ModelingSidebar/ModelingPanes/CodeEditor'
-import { useSelector } from '@xstate/react'
-
-const machineContextSelector = (snapshot?: {
-  context: Record<string, unknown>
-}) => snapshot?.context
 
 function CommandBarKclInput({
   arg,
@@ -36,44 +31,12 @@ function CommandBarKclInput({
     arg.name
   ] as KclCommandValue | undefined
   const { settings } = useSettingsAuthContext()
-  const argMachineContext = useSelector(
-    arg.machineActor,
-    machineContextSelector
-  )
-  const defaultValue = useMemo(
-    () =>
-      arg.defaultValue
-        ? arg.defaultValue instanceof Function
-          ? arg.defaultValue(commandBarState.context, argMachineContext)
-          : arg.defaultValue
-        : '',
-    [arg.defaultValue, commandBarState.context, argMachineContext]
-  )
-  const initialVariableName = useMemo(() => {
-    // Use the configured variable name if it exists
-    if (arg.variableName !== undefined) {
-      return arg.variableName instanceof Function
-        ? arg.variableName(commandBarState.context, argMachineContext)
-        : arg.variableName
-    }
-    // or derive it from the previously set value or the argument name
-    return previouslySetValue && 'variableName' in previouslySetValue
-      ? previouslySetValue.variableName
-      : arg.name
-  }, [
-    arg.variableName,
-    commandBarState.context,
-    argMachineContext,
-    arg.name,
-    previouslySetValue,
-  ])
+  const defaultValue = (arg.defaultValue as string) || ''
   const [value, setValue] = useState(
     previouslySetValue?.valueText || defaultValue || ''
   )
   const [createNewVariable, setCreateNewVariable] = useState(
-    (previouslySetValue && 'variableName' in previouslySetValue) ||
-      arg.createVariableByDefault ||
-      false
+    previouslySetValue && 'variableName' in previouslySetValue
   )
   const [canSubmit, setCanSubmit] = useState(true)
   useHotkeys('mod + k, mod + /', () => commandBarSend({ type: 'Close' }))
@@ -89,7 +52,10 @@ function CommandBarKclInput({
     isNewVariableNameUnique,
   } = useCalculateKclExpression({
     value,
-    initialVariableName,
+    initialVariableName:
+      previouslySetValue && 'variableName' in previouslySetValue
+        ? previouslySetValue.variableName
+        : arg.name,
   })
   const varMentionData: Completion[] = prevVariables.map((v) => ({
     label: v.key,

src/components/ContextMenu.tsx

@@ -1,23 +1,13 @@
 import toast from 'react-hot-toast'
 import { ActionIcon, ActionIconProps } from './ActionIcon'
-import {
-  MouseEvent,
-  RefObject,
-  useCallback,
-  useEffect,
-  useMemo,
-  useRef,
-  useState,
-} from 'react'
+import { RefObject, useEffect, useMemo, useRef, useState } from 'react'
 import { useHotkeys } from 'react-hotkeys-hook'
 import { Dialog } from '@headlessui/react'
 
-export interface ContextMenuProps
+interface ContextMenuProps
   extends Omit<React.HTMLAttributes<HTMLUListElement>, 'children'> {
   items?: React.ReactElement[]
   menuTargetElement?: RefObject<HTMLElement>
-  guard?: (e: globalThis.MouseEvent) => boolean
-  event?: 'contextmenu' | 'mouseup'
 }
 
 const DefaultContextMenuItems = [
@@ -30,8 +20,6 @@ export function ContextMenu({
   items = DefaultContextMenuItems,
   menuTargetElement,
   className,
-  guard,
-  event = 'contextmenu',
   ...props
 }: ContextMenuProps) {
   const dialogRef = useRef<HTMLDivElement>(null)
@@ -44,15 +32,6 @@ export function ContextMenu({
   useHotkeys('esc', () => setOpen(false), {
     enabled: open,
   })
-  const handleContextMenu = useCallback(
-    (e: globalThis.MouseEvent) => {
-      if (guard && !guard(e)) return
-      e.preventDefault()
-      setPosition({ x: e.clientX, y: e.clientY })
-      setOpen(true)
-    },
-    [guard, setPosition, setOpen]
-  )
 
   const dialogPositionStyle = useMemo(() => {
     if (!dialogRef.current)
@@ -99,9 +78,21 @@ export function ContextMenu({
 
   // Add context menu listener to target once mounted
   useEffect(() => {
-    menuTargetElement?.current?.addEventListener(event, handleContextMenu)
+    const handleContextMenu = (e: MouseEvent) => {
+      console.log('context menu', e)
+      e.preventDefault()
+      setPosition({ x: e.x, y: e.y })
+      setOpen(true)
+    }
+    menuTargetElement?.current?.addEventListener(
+      'contextmenu',
+      handleContextMenu
+    )
     return () => {
-      menuTargetElement?.current?.removeEventListener(event, handleContextMenu)
+      menuTargetElement?.current?.removeEventListener(
+        'contextmenu',
+        handleContextMenu
+      )
     }
   }, [menuTargetElement?.current])
 
@@ -109,10 +100,7 @@ export function ContextMenu({
     <Dialog open={open} onClose={() => setOpen(false)}>
       <div
         className="fixed inset-0 z-50 w-screen h-screen"
-        onContextMenu={(e) => {
-          e.preventDefault()
-          setPosition({ x: e.clientX, y: e.clientY })
-        }}
+        onContextMenu={(e) => e.preventDefault()}
       >
         <Dialog.Backdrop className="fixed z-10 inset-0" />
         <Dialog.Panel

src/components/Gizmo.tsx

@@ -1,6 +1,6 @@
 import { SceneInfra } from 'clientSideScene/sceneInfra'
 import { sceneInfra } from 'lib/singletons'
-import { MutableRefObject, useEffect, useRef } from 'react'
+import { MutableRefObject, useEffect, useMemo, useRef } from 'react'
 import {
   WebGLRenderer,
   Scene,
@@ -19,14 +19,16 @@ import {
   Intersection,
   Object3D,
 } from 'three'
+import {
+  ContextMenu,
+  ContextMenuDivider,
+  ContextMenuItem,
+  ContextMenuItemRefresh,
+} from './ContextMenu'
 import { Popover } from '@headlessui/react'
 import { CustomIcon } from './CustomIcon'
 import { reportRejection } from 'lib/trap'
-import {
-  useViewControlMenuItems,
-  ViewControlContextMenu,
-} from './ViewControlMenu'
-import { AxisNames } from 'lib/constants'
+import { useModelingContext } from 'hooks/useModelingContext'
 
 const CANVAS_SIZE = 80
 const FRUSTUM_SIZE = 0.5
@@ -38,14 +40,64 @@ enum AxisColors {
   Z = '#6689ef',
   Gray = '#c6c7c2',
 }
+enum AxisNames {
+  X = 'x',
+  Y = 'y',
+  Z = 'z',
+  NEG_X = '-x',
+  NEG_Y = '-y',
+  NEG_Z = '-z',
+}
+const axisNamesSemantic: Record<AxisNames, string> = {
+  [AxisNames.X]: 'Right',
+  [AxisNames.Y]: 'Back',
+  [AxisNames.Z]: 'Top',
+  [AxisNames.NEG_X]: 'Left',
+  [AxisNames.NEG_Y]: 'Front',
+  [AxisNames.NEG_Z]: 'Bottom',
+}
 
 export default function Gizmo() {
-  const menuItems = useViewControlMenuItems()
   const wrapperRef = useRef<HTMLDivElement | null>(null)
   const canvasRef = useRef<HTMLCanvasElement | null>(null)
   const raycasterIntersect = useRef<Intersection<Object3D> | null>(null)
   const cameraPassiveUpdateTimer = useRef(0)
   const raycasterPassiveUpdateTimer = useRef(0)
+  const { send: modelingSend } = useModelingContext()
+  const menuItems = useMemo(
+    () => [
+      ...Object.entries(axisNamesSemantic).map(([axisName, axisSemantic]) => (
+        <ContextMenuItem
+          key={axisName}
+          onClick={() => {
+            sceneInfra.camControls
+              .updateCameraToAxis(axisName as AxisNames)
+              .catch(reportRejection)
+          }}
+        >
+          {axisSemantic} view
+        </ContextMenuItem>
+      )),
+      <ContextMenuDivider />,
+      <ContextMenuItem
+        onClick={() => {
+          sceneInfra.camControls.resetCameraPosition().catch(reportRejection)
+        }}
+      >
+        Reset view
+      </ContextMenuItem>,
+      <ContextMenuItem
+        onClick={() => {
+          modelingSend({ type: 'Center camera on selection' })
+        }}
+      >
+        Center view on selection
+      </ContextMenuItem>,
+      <ContextMenuDivider />,
+      <ContextMenuItemRefresh />,
+    ],
+    [axisNamesSemantic]
+  )
 
   useEffect(() => {
     if (!canvasRef.current) return
@@ -109,7 +161,7 @@ export default function Gizmo() {
         className="grid place-content-center rounded-full overflow-hidden border border-solid border-primary/50 pointer-events-auto bg-chalkboard-10/70 dark:bg-chalkboard-100/80 backdrop-blur-sm"
       >
         <canvas ref={canvasRef} />
-        <ViewControlContextMenu menuTargetElement={wrapperRef} />
+        <ContextMenu menuTargetElement={wrapperRef} items={menuItems} />
       </div>
       <GizmoDropdown items={menuItems} />
     </div>

src/components/LowerRightControls.tsx

@@ -1,4 +1,4 @@
-import { APP_VERSION, getReleaseUrl } from 'routes/Settings'
+import { APP_VERSION } from 'routes/Settings'
 import { CustomIcon } from 'components/CustomIcon'
 import Tooltip from 'components/Tooltip'
 import { PATHS } from 'lib/paths'
@@ -72,8 +72,10 @@ export function LowerRightControls({
       <menu className="flex items-center justify-end gap-3 pointer-events-auto">
         {!location.pathname.startsWith(PATHS.HOME) && <ModelStateIndicator />}
         <a
-          onClick={openExternalBrowserIfDesktop(getReleaseUrl())}
-          href={getReleaseUrl()}
+          onClick={openExternalBrowserIfDesktop(
+            `https://github.com/KittyCAD/modeling-app/releases/tag/v${APP_VERSION}`
+          )}
+          href={`https://github.com/KittyCAD/modeling-app/releases/tag/v${APP_VERSION}`}
           target="_blank"
           rel="noopener noreferrer"
           className={'!no-underline font-mono text-xs ' + linkOverrideClassName}

src/components/LspProvider.tsx

@@ -69,7 +69,14 @@ export const LspProvider = ({ children }: { children: React.ReactNode }) => {
   const [isKclLspReady, setIsKclLspReady] = useState(false)
   const [isCopilotLspReady, setIsCopilotLspReady] = useState(false)
 
-  const { auth } = useSettingsAuthContext()
+  const {
+    auth,
+    settings: {
+      context: {
+        modeling: { defaultUnit },
+      },
+    },
+  } = useSettingsAuthContext()
   const token = auth?.context.token
   const navigate = useNavigate()
 
@@ -85,6 +92,7 @@ export const LspProvider = ({ children }: { children: React.ReactNode }) => {
     const initEvent: KclWorkerOptions = {
       wasmUrl: wasmUrl(),
       token: token,
+      baseUnit: defaultUnit.current,
       apiBaseUrl: VITE_KC_API_BASE_URL,
     }
     lspWorker.postMessage({

src/components/ModelingMachineProvider.tsx

@@ -24,7 +24,7 @@ import { useSetupEngineManager } from 'hooks/useSetupEngineManager'
 import { useSettingsAuthContext } from 'hooks/useSettingsAuthContext'
 import {
   isCursorInSketchCommandRange,
-  updateSketchDetailsNodePaths,
+  updatePathToNodeFromMap,
 } from 'lang/util'
 import {
   kclManager,
@@ -41,10 +41,7 @@ import {
   angleBetweenInfo,
   applyConstraintAngleBetween,
 } from './Toolbar/SetAngleBetween'
-import {
-  applyConstraintAngleLength,
-  applyConstraintLength,
-} from './Toolbar/setAngleLength'
+import { applyConstraintAngleLength } from './Toolbar/setAngleLength'
 import {
   canSweepSelection,
   handleSelectionBatch,
@@ -54,7 +51,6 @@ import {
   Selections,
   updateSelections,
   canLoftSelection,
-  canRevolveSelection,
   canShellSelection,
 } from 'lib/selections'
 import { applyConstraintIntersect } from './Toolbar/Intersect'
@@ -67,28 +63,17 @@ import {
   getSketchOrientationDetails,
 } from 'clientSideScene/sceneEntities'
 import {
-  insertNamedConstant,
-  replaceValueAtNodePath,
+  moveValueIntoNewVariablePath,
   sketchOnExtrudedFace,
   sketchOnOffsetPlane,
-  splitPipedProfile,
   startSketchOnDefault,
 } from 'lang/modifyAst'
-import {
-  PathToNode,
-  Program,
-  VariableDeclaration,
-  parse,
-  recast,
-  resultIsOk,
-} from 'lang/wasm'
+import { Program, parse, recast, resultIsOk } from 'lang/wasm'
 import {
   doesSceneHaveExtrudedSketch,
   doesSceneHaveSweepableSketch,
-  doesSketchPipeNeedSplitting,
-  getNodeFromPath,
-  isCursorInFunctionDefinition,
-  traverse,
+  getNodePathFromSourceRange,
+  isSingleCursorInPipe,
 } from 'lang/queryAst'
 import { exportFromEngine } from 'lib/exportFromEngine'
 import { Models } from '@kittycad/lib/dist/types/src'
@@ -96,7 +81,8 @@ import toast from 'react-hot-toast'
 import { EditorSelection, Transaction } from '@codemirror/state'
 import { useLoaderData, useNavigate, useSearchParams } from 'react-router-dom'
 import { letEngineAnimateAndSyncCamAfter } from 'clientSideScene/CameraControls'
-import { err, reportRejection, trap, reject } from 'lib/trap'
+import { getVarNameModal } from 'hooks/useToolbarGuards'
+import { err, reportRejection, trap } from 'lib/trap'
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { modelingMachineEvent } from 'editor/manager'
 import { hasValidEdgeTreatmentSelection } from 'lang/modifyAst/addEdgeTreatment'
@@ -110,10 +96,6 @@ import { useFileContext } from 'hooks/useFileContext'
 import { uuidv4 } from 'lib/utils'
 import { IndexLoaderData } from 'lib/types'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
-import {
-  getPathsFromArtifact,
-  getPlaneFromArtifact,
-} from 'lang/std/artifactGraph'
 
 type MachineContext<T extends AnyStateMachine> = {
   state: StateFrom<T>
@@ -304,7 +286,7 @@ export const ModelingMachineProvider = ({
           return {
             sketchDetails: {
               ...sketchDetails,
-              sketchEntryNodePath: event.data,
+              sketchPathToNode: event.data,
             },
           }
         }),
@@ -427,17 +409,9 @@ export const ModelingMachineProvider = ({
                 selectionRanges: setSelections.selection,
                 sketchDetails: {
                   ...sketchDetails,
-                  sketchEntryNodePath:
-                    setSelections.updatedSketchEntryNodePath ||
-                    sketchDetails?.sketchEntryNodePath ||
-                    [],
-                  sketchNodePaths:
-                    setSelections.updatedSketchNodePaths ||
-                    sketchDetails?.sketchNodePaths ||
-                    [],
-                  planeNodePath:
-                    setSelections.updatedPlaneNodePath ||
-                    sketchDetails?.planeNodePath ||
+                  sketchPathToNode:
+                    setSelections.updatedPathToNode ||
+                    sketchDetails?.sketchPathToNode ||
                     [],
                 },
               }
@@ -586,25 +560,6 @@ export const ModelingMachineProvider = ({
             isRangeBetweenCharacters(selectionRanges) ||
             isSelectionLastLine(selectionRanges, codeManager.code)
 
-          if (hasNoSelection) {
-            // they have no selection, we should enable the button
-            // so they can select the face through the cmdbar
-            // BUT only if there's extrudable geometry
-            return doesSceneHaveSweepableSketch(kclManager.ast)
-          }
-
-          const canSweep = canSweepSelection(selectionRanges)
-          if (err(canSweep)) return false
-          return canSweep
-        },
-        'has valid revolve selection': ({ context: { selectionRanges } }) => {
-          // A user can begin extruding if they either have 1+ faces selected or nothing selected
-          // TODO: I believe this guard only allows for extruding a single face at a time
-          const hasNoSelection =
-            selectionRanges.graphSelections.length === 0 ||
-            isRangeBetweenCharacters(selectionRanges) ||
-            isSelectionLastLine(selectionRanges, codeManager.code)
-
           if (hasNoSelection) {
             // they have no selection, we should enable the button
             // so they can select the face through the cmdbar
@@ -613,7 +568,7 @@ export const ModelingMachineProvider = ({
           }
           if (!isSketchPipe(selectionRanges)) return false
 
-          const canSweep = canRevolveSelection(selectionRanges)
+          const canSweep = canSweepSelection(selectionRanges)
           if (err(canSweep)) return false
           return canSweep
         },
@@ -646,6 +601,7 @@ export const ModelingMachineProvider = ({
           }
 
           const canShell = canShellSelection(selectionRanges)
+          console.log('canShellSelection', canShellSelection(selectionRanges))
           if (err(canShell)) return false
           return canShell
         },
@@ -668,12 +624,7 @@ export const ModelingMachineProvider = ({
         'Selection is on face': ({ context: { selectionRanges }, event }) => {
           if (event.type !== 'Enter sketch') return false
           if (event.data?.forceNewSketch) return false
-          if (
-            isCursorInFunctionDefinition(
-              kclManager.ast,
-              selectionRanges.graphSelections[0]
-            )
-          )
+          if (!isSingleCursorInPipe(selectionRanges, kclManager.ast))
             return false
           return !!isCursorInSketchCommandRange(
             engineCommandManager.artifactGraph,
@@ -704,32 +655,10 @@ export const ModelingMachineProvider = ({
               // this assumes no changes have been made to the sketch besides what we did when entering the sketch
               // i.e. doesn't account for user's adding code themselves, maybe we need store a flag userEditedSinceSketchMode?
               const newAst = structuredClone(kclManager.ast)
-              const varDecIndex = sketchDetails.planeNodePath[1][0]
-
-              const varDec = getNodeFromPath<VariableDeclaration>(
-                newAst,
-                sketchDetails.planeNodePath,
-                'VariableDeclaration'
-              )
-              if (err(varDec)) return reject(new Error('No varDec'))
-              const variableName = varDec.node.declaration.id.name
-              let isIdentifierUsed = false
-              traverse(newAst, {
-                enter: (node) => {
-                  if (
-                    node.type === 'Identifier' &&
-                    node.name === variableName
-                  ) {
-                    isIdentifierUsed = true
-                  }
-                },
-              })
-              if (isIdentifierUsed) return
-
+              const varDecIndex = sketchDetails.sketchPathToNode[1][0]
               // remove body item at varDecIndex
               newAst.body = newAst.body.filter((_, i) => i !== varDecIndex)
               await kclManager.executeAstMock(newAst)
-              await codeManager.updateEditorWithAstAndWriteToFile(newAst)
             }
             sceneInfra.setCallbacks({
               onClick: () => {},
@@ -739,7 +668,7 @@ export const ModelingMachineProvider = ({
           }
         ),
         'animate-to-face': fromPromise(async ({ input }) => {
-          if (!input) return null
+          if (!input) return undefined
           if (input.type === 'extrudeFace' || input.type === 'offsetPlane') {
             const sketched =
               input.type === 'extrudeFace'
@@ -766,9 +695,7 @@ export const ModelingMachineProvider = ({
             await letEngineAnimateAndSyncCamAfter(engineCommandManager, id)
             sceneInfra.camControls.syncDirection = 'clientToEngine'
             return {
-              sketchEntryNodePath: [],
-              planeNodePath: pathToNewSketchNode,
-              sketchNodePaths: [],
+              sketchPathToNode: pathToNewSketchNode,
               zAxis: input.zAxis,
               yAxis: input.yAxis,
               origin: input.position,
@@ -788,9 +715,7 @@ export const ModelingMachineProvider = ({
           )
 
           return {
-            sketchEntryNodePath: [],
-            planeNodePath: pathToNode,
-            sketchNodePaths: [],
+            sketchPathToNode: pathToNode,
             zAxis: input.zAxis,
             yAxis: input.yAxis,
             origin: [0, 0, 0],
@@ -798,14 +723,12 @@ export const ModelingMachineProvider = ({
         }),
         'animate-to-sketch': fromPromise(
           async ({ input: { selectionRanges } }) => {
-            const sketchPathToNode =
-              selectionRanges.graphSelections[0]?.codeRef?.pathToNode
-            const plane = getPlaneFromArtifact(
-              selectionRanges.graphSelections[0].artifact,
-              engineCommandManager.artifactGraph
+            const sourceRange =
+              selectionRanges.graphSelections[0]?.codeRef?.range
+            const sketchPathToNode = getNodePathFromSourceRange(
+              kclManager.ast,
+              sourceRange
             )
-            if (err(plane)) return Promise.reject(plane)
-
             const info = await getSketchOrientationDetails(
               sketchPathToNode || []
             )
@@ -813,17 +736,8 @@ export const ModelingMachineProvider = ({
               engineCommandManager,
               info?.sketchDetails?.faceId || ''
             )
-            const sketchPaths = getPathsFromArtifact({
-              artifact: selectionRanges.graphSelections[0].artifact,
-              sketchPathToNode: sketchPathToNode || [],
-            })
-            if (err(sketchPaths)) return Promise.reject(sketchPaths)
-            if (!plane.codeRef)
-              return Promise.reject(new Error('No plane codeRef'))
             return {
-              sketchEntryNodePath: sketchPathToNode || [],
-              sketchNodePaths: sketchPaths,
-              planeNodePath: plane.codeRef.pathToNode,
+              sketchPathToNode: sketchPathToNode || [],
               zAxis: info.sketchDetails.zAxis || null,
               yAxis: info.sketchDetails.yAxis || null,
               origin: info.sketchDetails.origin.map(
@@ -835,7 +749,7 @@ export const ModelingMachineProvider = ({
 
         'Get horizontal info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails } }) => {
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
+            const { modifiedAst, pathToNodeMap } =
               await applyConstraintHorzVertDistance({
                 constraint: 'setHorzDistance',
                 selectionRanges,
@@ -847,23 +761,13 @@ export const ModelingMachineProvider = ({
 
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
-
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -884,15 +788,13 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
         'Get vertical info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails } }) => {
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
+            const { modifiedAst, pathToNodeMap } =
               await applyConstraintHorzVertDistance({
                 constraint: 'setVertDistance',
                 selectionRanges,
@@ -903,23 +805,13 @@ export const ModelingMachineProvider = ({
             const _modifiedAst = pResult.program
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
-
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -940,9 +832,7 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
@@ -952,15 +842,14 @@ export const ModelingMachineProvider = ({
               selectionRanges,
             })
             if (err(info)) return Promise.reject(info)
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
-              await (info.enabled
-                ? applyConstraintAngleBetween({
-                    selectionRanges,
-                  })
-                : applyConstraintAngleLength({
-                    selectionRanges,
-                    angleOrLength: 'setAngle',
-                  }))
+            const { modifiedAst, pathToNodeMap } = await (info.enabled
+              ? applyConstraintAngleBetween({
+                  selectionRanges,
+                })
+              : applyConstraintAngleLength({
+                  selectionRanges,
+                  angleOrLength: 'setAngle',
+                }))
             const pResult = parse(recast(modifiedAst))
             if (trap(pResult) || !resultIsOk(pResult))
               return Promise.reject(new Error('Unexpected compilation error'))
@@ -969,23 +858,13 @@ export const ModelingMachineProvider = ({
 
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
-
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1006,47 +885,29 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
-        astConstrainLength: fromPromise(
-          async ({
-            input: { selectionRanges, sketchDetails, lengthValue },
-          }) => {
-            if (!lengthValue)
-              return Promise.reject(new Error('No length value'))
-            const constraintResult = await applyConstraintLength({
-              selectionRanges,
-              length: lengthValue,
-            })
-            if (err(constraintResult)) return Promise.reject(constraintResult)
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
-              constraintResult
+        'Get length info': fromPromise(
+          async ({ input: { selectionRanges, sketchDetails } }) => {
+            const { modifiedAst, pathToNodeMap } =
+              await applyConstraintAngleLength({
+                selectionRanges,
+              })
             const pResult = parse(recast(modifiedAst))
             if (trap(pResult) || !resultIsOk(pResult))
               return Promise.reject(new Error('Unexpected compilation error'))
             const _modifiedAst = pResult.program
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1067,15 +928,13 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
         'Get perpendicular distance info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails } }) => {
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
+            const { modifiedAst, pathToNodeMap } =
               await applyConstraintIntersect({
                 selectionRanges,
               })
@@ -1085,22 +944,13 @@ export const ModelingMachineProvider = ({
             const _modifiedAst = pResult.program
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1121,15 +971,13 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
         'Get ABS X info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails } }) => {
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
+            const { modifiedAst, pathToNodeMap } =
               await applyConstraintAbsDistance({
                 constraint: 'xAbs',
                 selectionRanges,
@@ -1140,22 +988,13 @@ export const ModelingMachineProvider = ({
             const _modifiedAst = pResult.program
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1176,15 +1015,13 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
         'Get ABS Y info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails } }) => {
-            const { modifiedAst, pathToNodeMap, exprInsertIndex } =
+            const { modifiedAst, pathToNodeMap } =
               await applyConstraintAbsDistance({
                 constraint: 'yAbs',
                 selectionRanges,
@@ -1195,22 +1032,13 @@ export const ModelingMachineProvider = ({
             const _modifiedAst = pResult.program
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex,
-            })
+            const updatedPathToNode = updatePathToNodeFromMap(
+              sketchDetails.sketchPathToNode,
+              pathToNodeMap
+            )
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                updatedPathToNode,
                 _modifiedAst,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1231,109 +1059,42 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
+              updatedPathToNode,
             }
           }
         ),
-        'Apply named value constraint': fromPromise(
+        'Get convert to variable info': fromPromise(
           async ({ input: { selectionRanges, sketchDetails, data } }) => {
-            if (!sketchDetails) {
+            if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
-            }
-            if (!data) {
-              return Promise.reject(new Error('No data from command flow'))
-            }
+            const { variableName } = await getVarNameModal({
+              valueName: data?.variableName || 'var',
+            })
             let pResult = parse(recast(kclManager.ast))
             if (trap(pResult) || !resultIsOk(pResult))
               return Promise.reject(new Error('Unexpected compilation error'))
             let parsed = pResult.program
 
-            let result: {
-              modifiedAst: Node<Program>
-              pathToReplaced: PathToNode | null
-              exprInsertIndex: number
-            } = {
-              modifiedAst: parsed,
-              pathToReplaced: null,
-              exprInsertIndex: -1,
-            }
-            // If the user provided a constant name,
-            // we need to insert the named constant
-            // and then replace the node with the constant's name.
-            if ('variableName' in data.namedValue) {
-              const astAfterReplacement = replaceValueAtNodePath({
-                ast: parsed,
-                pathToNode: data.currentValue.pathToNode,
-                newExpressionString: data.namedValue.variableName,
-              })
-              if (trap(astAfterReplacement)) {
-                return Promise.reject(astAfterReplacement)
-              }
-              const parseResultAfterInsertion = parse(
-                recast(
-                  insertNamedConstant({
-                    node: astAfterReplacement.modifiedAst,
-                    newExpression: data.namedValue,
-                  })
-                )
+            const { modifiedAst: _modifiedAst, pathToReplacedNode } =
+              moveValueIntoNewVariablePath(
+                parsed,
+                kclManager.programMemory,
+                data?.pathToNode || [],
+                variableName
               )
-              if (
-                trap(parseResultAfterInsertion) ||
-                !resultIsOk(parseResultAfterInsertion)
-              )
-                return Promise.reject(parseResultAfterInsertion)
-              result = {
-                modifiedAst: parseResultAfterInsertion.program,
-                pathToReplaced: astAfterReplacement.pathToReplaced,
-                exprInsertIndex: astAfterReplacement.exprInsertIndex,
-              }
-            } else if ('valueText' in data.namedValue) {
-              // If they didn't provide a constant name,
-              // just replace the node with the value.
-              const astAfterReplacement = replaceValueAtNodePath({
-                ast: parsed,
-                pathToNode: data.currentValue.pathToNode,
-                newExpressionString: data.namedValue.valueText,
-              })
-              if (trap(astAfterReplacement)) {
-                return Promise.reject(astAfterReplacement)
-              }
-              // The `replacer` function returns a pathToNode that assumes
-              // an identifier is also being inserted into the AST, creating an off-by-one error.
-              // This corrects that error, but TODO we should fix this upstream
-              // to avoid this kind of error in the future.
-              astAfterReplacement.pathToReplaced[1][0] =
-                (astAfterReplacement.pathToReplaced[1][0] as number) - 1
-              result = astAfterReplacement
-            }
-
-            pResult = parse(recast(result.modifiedAst))
+            pResult = parse(recast(_modifiedAst))
             if (trap(pResult) || !resultIsOk(pResult))
               return Promise.reject(new Error('Unexpected compilation error'))
             parsed = pResult.program
 
             if (trap(parsed)) return Promise.reject(parsed)
             parsed = parsed as Node<Program>
-            if (!result.pathToReplaced)
+            if (!pathToReplacedNode)
               return Promise.reject(new Error('No path to replaced node'))
-            const {
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            } = updateSketchDetailsNodePaths({
-              sketchEntryNodePath: sketchDetails.sketchEntryNodePath,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-              exprInsertIndex: result.exprInsertIndex,
-            })
 
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                updatedSketchEntryNodePath,
-                updatedSketchNodePaths,
-                updatedPlaneNodePath,
+                pathToReplacedNode || [],
                 parsed,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1346,7 +1107,7 @@ export const ModelingMachineProvider = ({
             )
 
             const selection = updateSelections(
-              { 0: result.pathToReplaced },
+              { 0: pathToReplacedNode },
               selectionRanges,
               updatedAst.newAst
             )
@@ -1354,140 +1115,7 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedSketchEntryNodePath,
-              updatedSketchNodePaths,
-              updatedPlaneNodePath,
-            }
-          }
-        ),
-        'set-up-draft-circle': fromPromise(
-          async ({ input: { sketchDetails, data } }) => {
-            if (!sketchDetails || !data)
-              return reject('No sketch details or data')
-            await sceneEntitiesManager.tearDownSketch({ removeAxis: false })
-
-            const result = await sceneEntitiesManager.setupDraftCircle(
-              sketchDetails.sketchEntryNodePath,
-              sketchDetails.sketchNodePaths,
-              sketchDetails.planeNodePath,
-              sketchDetails.zAxis,
-              sketchDetails.yAxis,
-              sketchDetails.origin,
-              data
-            )
-            if (err(result)) return reject(result)
-            await codeManager.updateEditorWithAstAndWriteToFile(kclManager.ast)
-
-            return result
-          }
-        ),
-        'set-up-draft-rectangle': fromPromise(
-          async ({ input: { sketchDetails, data } }) => {
-            if (!sketchDetails || !data)
-              return reject('No sketch details or data')
-            await sceneEntitiesManager.tearDownSketch({ removeAxis: false })
-
-            const result = await sceneEntitiesManager.setupDraftRectangle(
-              sketchDetails.sketchEntryNodePath,
-              sketchDetails.sketchNodePaths,
-              sketchDetails.planeNodePath,
-              sketchDetails.zAxis,
-              sketchDetails.yAxis,
-              sketchDetails.origin,
-              data
-            )
-            if (err(result)) return reject(result)
-            await codeManager.updateEditorWithAstAndWriteToFile(kclManager.ast)
-
-            return result
-          }
-        ),
-        'set-up-draft-center-rectangle': fromPromise(
-          async ({ input: { sketchDetails, data } }) => {
-            if (!sketchDetails || !data)
-              return reject('No sketch details or data')
-            await sceneEntitiesManager.tearDownSketch({ removeAxis: false })
-            const result = await sceneEntitiesManager.setupDraftCenterRectangle(
-              sketchDetails.sketchEntryNodePath,
-              sketchDetails.sketchNodePaths,
-              sketchDetails.planeNodePath,
-              sketchDetails.zAxis,
-              sketchDetails.yAxis,
-              sketchDetails.origin,
-              data
-            )
-            if (err(result)) return reject(result)
-            await codeManager.updateEditorWithAstAndWriteToFile(kclManager.ast)
-
-            return result
-          }
-        ),
-        'setup-client-side-sketch-segments': fromPromise(
-          async ({ input: { sketchDetails, selectionRanges } }) => {
-            if (!sketchDetails) return
-            if (!sketchDetails.sketchEntryNodePath.length) return
-            if (Object.keys(sceneEntitiesManager.activeSegments).length > 0) {
-              sceneEntitiesManager.tearDownSketch({ removeAxis: false })
-            }
-            sceneInfra.resetMouseListeners()
-            await sceneEntitiesManager.setupSketch({
-              sketchEntryNodePath: sketchDetails?.sketchEntryNodePath || [],
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              forward: sketchDetails.zAxis,
-              up: sketchDetails.yAxis,
-              position: sketchDetails.origin,
-              maybeModdedAst: kclManager.ast,
-              selectionRanges,
-            })
-            sceneInfra.resetMouseListeners()
-
-            sceneEntitiesManager.setupSketchIdleCallbacks({
-              sketchEntryNodePath: sketchDetails?.sketchEntryNodePath || [],
-              forward: sketchDetails.zAxis,
-              up: sketchDetails.yAxis,
-              position: sketchDetails.origin,
-              sketchNodePaths: sketchDetails.sketchNodePaths,
-              planeNodePath: sketchDetails.planeNodePath,
-            })
-            return undefined
-          }
-        ),
-        'split-sketch-pipe-if-needed': fromPromise(
-          async ({ input: { sketchDetails } }) => {
-            if (!sketchDetails) return reject('No sketch details')
-            const existingSketchInfoNoOp = {
-              updatedEntryNodePath: sketchDetails.sketchEntryNodePath,
-              updatedSketchNodePaths: sketchDetails.sketchNodePaths,
-              updatedPlaneNodePath: sketchDetails.planeNodePath,
-            } as const
-            if (
-              !sketchDetails.sketchNodePaths.length &&
-              sketchDetails.planeNodePath.length
-            ) {
-              // new sketch, no profiles yet
-              return existingSketchInfoNoOp
-            }
-            const doesNeedSplitting = doesSketchPipeNeedSplitting(
-              kclManager.ast,
-              sketchDetails.sketchEntryNodePath
-            )
-            if (err(doesNeedSplitting)) return reject(doesNeedSplitting)
-            if (!doesNeedSplitting) return existingSketchInfoNoOp
-
-            const splitResult = splitPipedProfile(
-              kclManager.ast,
-              sketchDetails.sketchEntryNodePath
-            )
-            if (err(splitResult)) return reject(splitResult)
-
-            await kclManager.executeAstMock(splitResult.modifiedAst)
-            await codeManager.updateEditorWithAstAndWriteToFile(
-              splitResult.modifiedAst
-            )
-            return {
-              updatedEntryNodePath: splitResult.pathToProfile,
-              updatedSketchNodePaths: [splitResult.pathToProfile],
-              updatedPlaneNodePath: sketchDetails.planeNodePath,
+              updatedPathToNode: pathToReplacedNode,
             }
           }
         ),

src/components/ModelingSidebar/ModelingPane.tsx

@@ -76,7 +76,7 @@ export const ModelingPane = ({
   return (
     <section
       {...props}
-      aria-label={title && typeof title === 'string' ? title : ''}
+      title={title && typeof title === 'string' ? title : ''}
       data-testid={detailsTestId}
       id={id}
       className={

src/components/Settings/AllKeybindingsFields.tsx

@@ -10,7 +10,7 @@ interface AllKeybindingsFieldsProps {}
 
 export const AllKeybindingsFields = forwardRef(
   (
-    _props: AllKeybindingsFieldsProps,
+    props: AllKeybindingsFieldsProps,
     scrollRef: ForwardedRef<HTMLDivElement>
   ) => {
     // This is how we will get the interaction map from the context
@@ -25,7 +25,7 @@ export const AllKeybindingsFields = forwardRef(
             .map(([category, categoryItems]) => (
               <div className="flex flex-col gap-4 px-2 pr-4">
                 <h2
-                  id={`category-${category.replaceAll(/\s/g, '-')}`}
+                  id={`category-${category}`}
                   className="text-xl mt-6 first-of-type:mt-0 capitalize font-bold"
                 >
                   {category}

src/components/Settings/AllSettingsFields.tsx

@@ -13,7 +13,7 @@ import { isDesktop } from 'lib/isDesktop'
 import { ActionButton } from 'components/ActionButton'
 import { SettingsFieldInput } from './SettingsFieldInput'
 import toast from 'react-hot-toast'
-import { APP_VERSION, IS_NIGHTLY, getReleaseUrl } from 'routes/Settings'
+import { APP_VERSION, PACKAGE_NAME } from 'routes/Settings'
 import { PATHS } from 'lib/paths'
 import {
   createAndOpenNewTutorialProject,
@@ -246,8 +246,10 @@ export const AllSettingsFields = forwardRef(
                   to inject the version from package.json */}
               App version {APP_VERSION}.{' '}
               <a
-                onClick={openExternalBrowserIfDesktop(getReleaseUrl())}
-                href={getReleaseUrl()}
+                onClick={openExternalBrowserIfDesktop(
+                  `https://github.com/KittyCAD/modeling-app/releases/tag/v${APP_VERSION}`
+                )}
+                href={`https://github.com/KittyCAD/modeling-app/releases/tag/v${APP_VERSION}`}
                 target="_blank"
                 rel="noopener noreferrer"
               >
@@ -269,7 +271,7 @@ export const AllSettingsFields = forwardRef(
               , and start a discussion if you don't see it! Your feedback will
               help us prioritize what to build next.
             </p>
-            {!IS_NIGHTLY && (
+            {PACKAGE_NAME.indexOf('-nightly') === -1 && (
               <p className="max-w-2xl mt-6">
                 Want to experience the latest and (hopefully) greatest from our
                 main development branch?{' '}

src/components/Settings/KeybindingsSectionsList.tsx

@@ -19,7 +19,7 @@ export function KeybindingsSectionsList({
             key={category}
             onClick={() =>
               scrollRef.current
-                ?.querySelector(`#category-${category.replaceAll(/\s/g, '-')}`)
+                ?.querySelector(`#category-${category}`)
                 ?.scrollIntoView({
                   block: 'center',
                   behavior: 'smooth',

src/components/SettingsAuthProvider.tsx

@@ -1,5 +1,5 @@
 import { trap } from 'lib/trap'
-import { useMachine, useSelector } from '@xstate/react'
+import { useMachine } from '@xstate/react'
 import { useNavigate, useRouteLoaderData, useLocation } from 'react-router-dom'
 import { PATHS, BROWSER_PATH } from 'lib/paths'
 import { authMachine, TOKEN_PERSIST_KEY } from '../machines/authMachine'
@@ -23,6 +23,7 @@ import {
   engineCommandManager,
   sceneEntitiesManager,
 } from 'lib/singletons'
+import { uuidv4 } from 'lib/utils'
 import { IndexLoaderData } from 'lib/types'
 import { settings } from 'lib/settings/initialSettings'
 import {
@@ -54,15 +55,11 @@ type SettingsAuthContextType = {
   settings: MachineContext<typeof settingsMachine>
 }
 
-/**
- * This variable is used to store the last snapshot of the settings context
- * for use outside of React, such as in `wasm.ts`. It is updated every time
- * the settings machine changes with `useSelector`.
- * TODO: when we decouple XState from React, we can just subscribe to the actor directly from `wasm.ts`
- */
-export let lastSettingsContextSnapshot:
-  | ContextFrom<typeof settingsMachine>
-  | undefined
+// a little hacky for sure, open to changing it
+// this implies that we should only even have one instance of this provider mounted at any one time
+// but I think that's a safe assumption
+let settingsStateRef: ContextFrom<typeof settingsMachine> | undefined
+export const getSettingsState = () => settingsStateRef
 
 export const SettingsAuthContext = createContext({} as SettingsAuthContextType)
 
@@ -132,11 +129,27 @@ export const SettingsAuthProviderBase = ({
             .setTheme(context.app.theme.current)
             .catch(reportRejection)
         },
+        setEngineScaleGridVisibility: ({ context }) => {
+          engineCommandManager.setScaleGridVisibility(
+            context.modeling.showScaleGrid.current
+          )
+        },
         setClientTheme: ({ context }) => {
           const opposingTheme = getOppositeTheme(context.app.theme.current)
           sceneInfra.theme = opposingTheme
           sceneEntitiesManager.updateSegmentBaseColor(opposingTheme)
         },
+        setEngineEdges: ({ context }) => {
+          // eslint-disable-next-line @typescript-eslint/no-floating-promises
+          engineCommandManager.sendSceneCommand({
+            cmd_id: uuidv4(),
+            type: 'modeling_cmd_req',
+            cmd: {
+              type: 'edge_lines_visible' as any, // TODO update kittycad.ts to get this new command type
+              hidden: !context.modeling.highlightEdges.current,
+            },
+          })
+        },
         toastSuccess: ({ event }) => {
           if (!('data' in event)) return
           const eventParts = event.type.replace(/^set./, '').split('.') as [
@@ -162,27 +175,17 @@ export const SettingsAuthProviderBase = ({
         },
         'Execute AST': ({ context, event }) => {
           try {
-            const relevantSetting = (s: typeof settings) => {
-              return (
-                s.modeling?.defaultUnit?.current !==
-                  context.modeling.defaultUnit.current ||
-                s.modeling.showScaleGrid.current !==
-                  context.modeling.showScaleGrid.current ||
-                s.modeling?.highlightEdges.current !==
-                  context.modeling.highlightEdges.current
-              )
-            }
-
             const allSettingsIncludesUnitChange =
               event.type === 'Set all settings' &&
-              relevantSetting(event.settings)
+              event.settings?.modeling?.defaultUnit?.current !==
+                context.modeling.defaultUnit.current
             const resetSettingsIncludesUnitChange =
-              event.type === 'Reset settings' && relevantSetting(settings)
+              event.type === 'Reset settings' &&
+              context.modeling.defaultUnit.current !==
+                settings?.modeling?.defaultUnit?.default
 
             if (
               event.type === 'set.modeling.defaultUnit' ||
-              event.type === 'set.modeling.showScaleGrid' ||
-              event.type === 'set.modeling.highlightEdges' ||
               allSettingsIncludesUnitChange ||
               resetSettingsIncludesUnitChange
             ) {
@@ -211,10 +214,7 @@ export const SettingsAuthProviderBase = ({
     }),
     { input: loadedSettings }
   )
-  // Any time the actor changes, update the settings state for external use
-  useSelector(settingsActor, (s) => {
-    lastSettingsContextSnapshot = s.context
-  })
+  settingsStateRef = settingsState.context
 
   useEffect(() => {
     if (!isDesktop()) return

src/components/Stream.tsx

@@ -20,7 +20,6 @@ import { IndexLoaderData } from 'lib/types'
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { err, reportRejection } from 'lib/trap'
 import { getArtifactOfTypes } from 'lang/std/artifactGraph'
-import { ViewControlContextMenu } from './ViewControlMenu'
 
 enum StreamState {
   Playing = 'playing',
@@ -31,7 +30,6 @@ enum StreamState {
 
 export const Stream = () => {
   const [isLoading, setIsLoading] = useState(true)
-  const videoWrapperRef = useRef<HTMLDivElement>(null)
   const videoRef = useRef<HTMLVideoElement>(null)
   const { settings } = useSettingsAuthContext()
   const { state, send } = useModelingContext()
@@ -260,7 +258,7 @@ export const Stream = () => {
     setIsLoading(false)
   }, [mediaStream])
 
-  const handleClick: MouseEventHandler<HTMLDivElement> = (e) => {
+  const handleMouseUp: MouseEventHandler<HTMLDivElement> = (e) => {
     // If we've got no stream or connection, don't do anything
     if (!isNetworkOkay) return
     if (!videoRef.current) return
@@ -322,11 +320,10 @@ export const Stream = () => {
 
   return (
     <div
-      ref={videoWrapperRef}
       className="absolute inset-0 z-0"
       id="stream"
       data-testid="stream"
-      onClick={handleClick}
+      onClick={handleMouseUp}
       onDoubleClick={enterSketchModeIfSelectingSketch}
       onContextMenu={(e) => e.preventDefault()}
       onContextMenuCapture={(e) => e.preventDefault()}
@@ -387,14 +384,6 @@ export const Stream = () => {
           </Loading>
         </div>
       )}
-      <ViewControlContextMenu
-        event="mouseup"
-        guard={(e) =>
-          sceneInfra.camControls.wasDragging === false &&
-          btnName(e).right === true
-        }
-        menuTargetElement={videoWrapperRef}
-      />
     </div>
   )
 }

src/components/ToastUpdate.tsx

@@ -2,7 +2,6 @@ import toast from 'react-hot-toast'
 import { ActionButton } from './ActionButton'
 import { openExternalBrowserIfDesktop } from 'lib/openWindow'
 import { Marked } from '@ts-stack/markdown'
-import { getReleaseUrl } from 'routes/Settings'
 
 export function ToastUpdate({
   version,
@@ -33,8 +32,10 @@ export function ToastUpdate({
             A new update has downloaded and will be available next time you
             start the app. You can view the release notes{' '}
             <a
-              onClick={openExternalBrowserIfDesktop(getReleaseUrl(version))}
-              href={getReleaseUrl(version)}
+              onClick={openExternalBrowserIfDesktop(
+                `https://github.com/KittyCAD/modeling-app/releases/tag/v${version}`
+              )}
+              href={`https://github.com/KittyCAD/modeling-app/releases/tag/v${version}`}
               target="_blank"
               rel="noreferrer"
             >

src/components/Toolbar/Intersect.tsx

@@ -136,7 +136,6 @@ export async function applyConstraintIntersect({
 }): Promise<{
   modifiedAst: Node<Program>
   pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
 }> {
   const info = intersectInfo({
     selectionRanges,
@@ -175,7 +174,6 @@ export async function applyConstraintIntersect({
     return {
       modifiedAst,
       pathToNodeMap,
-      exprInsertIndex: -1,
     }
   }
   // transform again but forcing certain values
@@ -194,7 +192,6 @@ export async function applyConstraintIntersect({
   const { modifiedAst: _modifiedAst, pathToNodeMap: _pathToNodeMap } =
     transform2
 
-  let exprInsertIndex = -1
   if (variableName) {
     const newBody = [..._modifiedAst.body]
     newBody.splice(
@@ -207,11 +204,9 @@ export async function applyConstraintIntersect({
       const index = pathToNode.findIndex((a) => a[0] === 'body') + 1
       pathToNode[index][0] = Number(pathToNode[index][0]) + 1
     })
-    exprInsertIndex = newVariableInsertIndex
   }
   return {
     modifiedAst: _modifiedAst,
     pathToNodeMap: _pathToNodeMap,
-    exprInsertIndex,
   }
 }

src/components/Toolbar/RemoveConstrainingValues.tsx

@@ -28,7 +28,7 @@ export function removeConstrainingValuesInfo({
   | Error {
   const _nodes = selectionRanges.graphSelections.map(({ codeRef }) => {
     const tmp = getNodeFromPath<Expr>(kclManager.ast, codeRef.pathToNode)
-    if (tmp instanceof Error) return tmp
+    if (err(tmp)) return tmp
     return tmp.node
   })
   const _err1 = _nodes.find(err)

src/components/Toolbar/SetAbsDistance.tsx

@@ -93,7 +93,6 @@ export async function applyConstraintAbsDistance({
 }): Promise<{
   modifiedAst: Program
   pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
 }> {
   const info = absDistanceInfo({
     selectionRanges,
@@ -133,7 +132,6 @@ export async function applyConstraintAbsDistance({
   if (err(transform2)) return Promise.reject(transform2)
   const { modifiedAst: _modifiedAst, pathToNodeMap } = transform2
 
-  let exprInsertIndex = -1
   if (variableName) {
     const newBody = [..._modifiedAst.body]
     newBody.splice(
@@ -146,9 +144,8 @@ export async function applyConstraintAbsDistance({
       const index = pathToNode.findIndex((a) => a[0] === 'body') + 1
       pathToNode[index][0] = Number(pathToNode[index][0]) + 1
     })
-    exprInsertIndex = newVariableInsertIndex
   }
-  return { modifiedAst: _modifiedAst, pathToNodeMap, exprInsertIndex }
+  return { modifiedAst: _modifiedAst, pathToNodeMap }
 }
 
 export function applyConstraintAxisAlign({

src/components/Toolbar/SetAngleBetween.tsx

@@ -86,7 +86,6 @@ export async function applyConstraintAngleBetween({
 }): Promise<{
   modifiedAst: Program
   pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
 }> {
   const info = angleBetweenInfo({ selectionRanges })
   if (err(info)) return Promise.reject(info)
@@ -123,7 +122,6 @@ export async function applyConstraintAngleBetween({
     return {
       modifiedAst,
       pathToNodeMap,
-      exprInsertIndex: -1,
     }
   }
 
@@ -143,7 +141,6 @@ export async function applyConstraintAngleBetween({
   const { modifiedAst: _modifiedAst, pathToNodeMap: _pathToNodeMap } =
     transformed2
 
-  let exprInsertIndex = -1
   if (variableName) {
     const newBody = [..._modifiedAst.body]
     newBody.splice(
@@ -156,11 +153,9 @@ export async function applyConstraintAngleBetween({
       const index = pathToNode.findIndex((a) => a[0] === 'body') + 1
       pathToNode[index][0] = Number(pathToNode[index][0]) + 1
     })
-    exprInsertIndex = newVariableInsertIndex
   }
   return {
     modifiedAst: _modifiedAst,
     pathToNodeMap: _pathToNodeMap,
-    exprInsertIndex,
   }
 }

src/components/Toolbar/SetHorzVertDistance.tsx

@@ -87,13 +87,15 @@ export function horzVertDistanceInfo({
 export async function applyConstraintHorzVertDistance({
   selectionRanges,
   constraint,
+  // TODO align will always be false (covered by synconous applyConstraintHorzVertAlign), remove it
+  isAlign = false,
 }: {
   selectionRanges: Selections
   constraint: 'setHorzDistance' | 'setVertDistance'
+  isAlign?: false
 }): Promise<{
   modifiedAst: Program
   pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
 }> {
   const info = horzVertDistanceInfo({
     selectionRanges: selectionRanges,
@@ -131,12 +133,13 @@ export async function applyConstraintHorzVertDistance({
     return {
       modifiedAst,
       pathToNodeMap,
-      exprInsertIndex: -1,
     }
   } else {
     if (!isExprBinaryPart(valueNode))
       return Promise.reject('Invalid valueNode, is not a BinaryPart')
-    let finalValue = removeDoubleNegatives(valueNode, sign, variableName)
+    let finalValue = isAlign
+      ? createLiteral(0)
+      : removeDoubleNegatives(valueNode, sign, variableName)
     // transform again but forcing certain values
     const transformed = transformSecondarySketchLinesTagFirst({
       ast: kclManager.ast,
@@ -149,7 +152,6 @@ export async function applyConstraintHorzVertDistance({
 
     if (err(transformed)) return Promise.reject(transformed)
     const { modifiedAst: _modifiedAst, pathToNodeMap } = transformed
-    let exprInsertIndex = -1
     if (variableName) {
       const newBody = [..._modifiedAst.body]
       newBody.splice(
@@ -162,12 +164,10 @@ export async function applyConstraintHorzVertDistance({
         const index = pathToNode.findIndex((a) => a[0] === 'body') + 1
         pathToNode[index][0] = Number(pathToNode[index][0]) + 1
       })
-      exprInsertIndex = newVariableInsertIndex
     }
     return {
       modifiedAst: _modifiedAst,
       pathToNodeMap,
-      exprInsertIndex,
     }
   }
 }

src/components/Toolbar/setAngleLength.tsx

@@ -22,7 +22,6 @@ import { removeDoubleNegatives } from '../AvailableVarsHelpers'
 import { normaliseAngle } from '../../lib/utils'
 import { kclManager } from 'lib/singletons'
 import { err } from 'lib/trap'
-import { KclCommandValue } from 'lib/commandTypes'
 
 const getModalInfo = createSetAngleLengthModal(SetAngleLengthModal)
 
@@ -64,67 +63,6 @@ export function angleLengthInfo({
   return { enabled, transforms }
 }
 
-export async function applyConstraintLength({
-  length,
-  selectionRanges,
-}: {
-  length: KclCommandValue
-  selectionRanges: Selections
-}): Promise<{
-  modifiedAst: Program
-  pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
-}> {
-  const ast = kclManager.ast
-  const angleLength = angleLengthInfo({ selectionRanges })
-  if (err(angleLength)) return Promise.reject(angleLength)
-  const { transforms } = angleLength
-
-  let distanceExpression: Expr = length.valueAst
-
-  /**
-   * To be "constrained", the value must be a binary expression, a named value, or a function call.
-   * If it has a variable name, we need to insert a variable declaration at the correct index.
-   */
-  if (
-    'variableName' in length &&
-    length.variableName &&
-    length.insertIndex !== undefined
-  ) {
-    const newBody = [...ast.body]
-    newBody.splice(length.insertIndex, 0, length.variableDeclarationAst)
-    ast.body = newBody
-    distanceExpression = createIdentifier(length.variableName)
-  }
-
-  if (!isExprBinaryPart(distanceExpression)) {
-    return Promise.reject('Invalid valueNode, is not a BinaryPart')
-  }
-
-  const retval = transformAstSketchLines({
-    ast,
-    selectionRanges,
-    transformInfos: transforms,
-    programMemory: kclManager.programMemory,
-    referenceSegName: '',
-    forceValueUsedInTransform: distanceExpression,
-  })
-  if (err(retval)) return Promise.reject(retval)
-
-  const { modifiedAst: _modifiedAst, pathToNodeMap } = retval
-
-  return {
-    modifiedAst: _modifiedAst,
-    pathToNodeMap,
-    exprInsertIndex:
-      'variableName' in length &&
-      length.variableName &&
-      length.insertIndex !== undefined
-        ? length.insertIndex
-        : -1,
-  }
-}
-
 export async function applyConstraintAngleLength({
   selectionRanges,
   angleOrLength = 'setLength',
@@ -134,7 +72,6 @@ export async function applyConstraintAngleLength({
 }): Promise<{
   modifiedAst: Program
   pathToNodeMap: PathToNodeMap
-  exprInsertIndex: number
 }> {
   const angleLength = angleLengthInfo({ selectionRanges, angleOrLength })
   if (err(angleLength)) return Promise.reject(angleLength)
@@ -219,6 +156,5 @@ export async function applyConstraintAngleLength({
   return {
     modifiedAst: _modifiedAst,
     pathToNodeMap,
-    exprInsertIndex: variableName ? newVariableInsertIndex : -1,
   }
 }

src/components/UnitsMenu.tsx

@@ -41,10 +41,7 @@ export function UnitsMenu() {
                       close()
                     }}
                   >
-                    <span className="flex-1">{baseUnitLabels[unit]}</span>
-                    {unit === settings.context.modeling.defaultUnit.current && (
-                      <span className="text-chalkboard-60">current</span>
-                    )}
+                    {baseUnitLabels[unit]}
                   </button>
                 </li>
               ))}

src/components/ViewControlMenu.tsx

@@ -1,66 +0,0 @@
-import { reportRejection } from 'lib/trap'
-import {
-  ContextMenu,
-  ContextMenuDivider,
-  ContextMenuItem,
-  ContextMenuItemRefresh,
-  ContextMenuProps,
-} from './ContextMenu'
-import { AxisNames, VIEW_NAMES_SEMANTIC } from 'lib/constants'
-import { useModelingContext } from 'hooks/useModelingContext'
-import { useMemo } from 'react'
-import { sceneInfra } from 'lib/singletons'
-
-export function useViewControlMenuItems() {
-  const { send: modelingSend } = useModelingContext()
-  const menuItems = useMemo(
-    () => [
-      ...Object.entries(VIEW_NAMES_SEMANTIC).map(([axisName, axisSemantic]) => (
-        <ContextMenuItem
-          key={axisName}
-          onClick={() => {
-            sceneInfra.camControls
-              .updateCameraToAxis(axisName as AxisNames)
-              .catch(reportRejection)
-          }}
-        >
-          {axisSemantic} view
-        </ContextMenuItem>
-      )),
-      <ContextMenuDivider />,
-      <ContextMenuItem
-        onClick={() => {
-          sceneInfra.camControls.resetCameraPosition().catch(reportRejection)
-        }}
-      >
-        Reset view
-      </ContextMenuItem>,
-      <ContextMenuItem
-        onClick={() => {
-          modelingSend({ type: 'Center camera on selection' })
-        }}
-      >
-        Center view on selection
-      </ContextMenuItem>,
-      <ContextMenuDivider />,
-      <ContextMenuItemRefresh />,
-    ],
-    [VIEW_NAMES_SEMANTIC]
-  )
-  return menuItems
-}
-
-export function ViewControlContextMenu({
-  menuTargetElement: wrapperRef,
-  ...props
-}: ContextMenuProps) {
-  const menuItems = useViewControlMenuItems()
-  return (
-    <ContextMenu
-      data-testid="view-controls-menu"
-      menuTargetElement={wrapperRef}
-      items={menuItems}
-      {...props}
-    />
-  )
-}

src/editor/plugins/lsp/kcl/colors.ts

@@ -1,327 +0,0 @@
-import {
-  EditorView,
-  WidgetType,
-  ViewUpdate,
-  ViewPlugin,
-  DecorationSet,
-  Decoration,
-} from '@codemirror/view'
-import { Range, Extension, Text } from '@codemirror/state'
-import { NodeProp, Tree } from '@lezer/common'
-import { language, syntaxTree } from '@codemirror/language'
-
-interface PickerState {
-  from: number
-  to: number
-  alpha: string
-  colorType: ColorType
-}
-
-export interface WidgetOptions extends PickerState {
-  color: string
-}
-
-export type ColorData = Omit<WidgetOptions, 'from' | 'to'>
-
-const pickerState = new WeakMap<HTMLInputElement, PickerState>()
-
-export enum ColorType {
-  hex = 'HEX',
-}
-
-const hexRegex = /(^|\b)(#[0-9a-f]{3,9})(\b|$)/i
-
-function discoverColorsInKCL(
-  syntaxTree: Tree,
-  from: number,
-  to: number,
-  typeName: string,
-  doc: Text,
-  language?: string
-): WidgetOptions | Array<WidgetOptions> | null {
-  switch (typeName) {
-    case 'Program':
-    case 'VariableDeclaration':
-    case 'CallExpression':
-    case 'ObjectExpression':
-    case 'ObjectProperty':
-    case 'ArgumentList':
-    case 'PipeExpression': {
-      let innerTree = syntaxTree.resolveInner(from, 0).tree
-
-      if (!innerTree) {
-        innerTree = syntaxTree.resolveInner(from, 1).tree
-        if (!innerTree) {
-          return null
-        }
-      }
-
-      const overlayTree = innerTree.prop(NodeProp.mounted)?.tree
-
-      if (overlayTree?.type.name !== 'Styles') {
-        return null
-      }
-
-      const ret: Array<WidgetOptions> = []
-      overlayTree.iterate({
-        from: 0,
-        to: overlayTree.length,
-        enter: ({ type, from: overlayFrom, to: overlayTo }) => {
-          const maybeWidgetOptions = discoverColorsInKCL(
-            syntaxTree,
-            // We add one because the tree doesn't include the
-            // quotation mark from the style tag
-            from + 1 + overlayFrom,
-            from + 1 + overlayTo,
-            type.name,
-            doc,
-            language
-          )
-
-          if (maybeWidgetOptions) {
-            if (Array.isArray(maybeWidgetOptions)) {
-              console.error('Unexpected nested overlays')
-              ret.push(...maybeWidgetOptions)
-            } else {
-              ret.push(maybeWidgetOptions)
-            }
-          }
-        },
-      })
-
-      return ret
-    }
-
-    case 'String': {
-      const result = parseColorLiteral(doc.sliceString(from, to))
-      if (!result) {
-        return null
-      }
-      return {
-        ...result,
-        from,
-        to,
-      }
-    }
-
-    default:
-      return null
-  }
-}
-
-export function parseColorLiteral(colorLiteral: string): ColorData | null {
-  const literal = colorLiteral.replace(/"/g, '')
-  const match = hexRegex.exec(literal)
-  if (!match) {
-    return null
-  }
-  const [color, alpha] = toFullHex(literal)
-
-  return {
-    colorType: ColorType.hex,
-    color,
-    alpha,
-  }
-}
-
-function colorPickersDecorations(
-  view: EditorView,
-  discoverColors: typeof discoverColorsInKCL
-) {
-  const widgets: Array<Range<Decoration>> = []
-
-  const st = syntaxTree(view.state)
-
-  for (const range of view.visibleRanges) {
-    st.iterate({
-      from: range.from,
-      to: range.to,
-      enter: ({ type, from, to }) => {
-        const maybeWidgetOptions = discoverColors(
-          st,
-          from,
-          to,
-          type.name,
-          view.state.doc,
-          view.state.facet(language)?.name
-        )
-
-        if (!maybeWidgetOptions) {
-          return
-        }
-
-        if (!Array.isArray(maybeWidgetOptions)) {
-          widgets.push(
-            Decoration.widget({
-              widget: new ColorPickerWidget(maybeWidgetOptions),
-              side: 1,
-            }).range(maybeWidgetOptions.from)
-          )
-
-          return
-        }
-
-        for (const wo of maybeWidgetOptions) {
-          widgets.push(
-            Decoration.widget({
-              widget: new ColorPickerWidget(wo),
-              side: 1,
-            }).range(wo.from)
-          )
-        }
-      },
-    })
-  }
-
-  return Decoration.set(widgets)
-}
-
-function toFullHex(color: string): string[] {
-  if (color.length === 4) {
-    // 3-char hex
-    return [
-      `#${color[1].repeat(2)}${color[2].repeat(2)}${color[3].repeat(2)}`,
-      '',
-    ]
-  }
-
-  if (color.length === 5) {
-    // 4-char hex (alpha)
-    return [
-      `#${color[1].repeat(2)}${color[2].repeat(2)}${color[3].repeat(2)}`,
-      color[4].repeat(2),
-    ]
-  }
-
-  if (color.length === 9) {
-    // 8-char hex (alpha)
-    return [`#${color.slice(1, -2)}`, color.slice(-2)]
-  }
-
-  return [color, '']
-}
-
-export const wrapperClassName = 'cm-css-color-picker-wrapper'
-
-class ColorPickerWidget extends WidgetType {
-  private readonly state: PickerState
-  private readonly color: string
-
-  constructor({ color, ...state }: WidgetOptions) {
-    super()
-    this.state = state
-    this.color = color
-  }
-
-  eq(other: ColorPickerWidget) {
-    return (
-      other.state.colorType === this.state.colorType &&
-      other.color === this.color &&
-      other.state.from === this.state.from &&
-      other.state.to === this.state.to &&
-      other.state.alpha === this.state.alpha
-    )
-  }
-
-  toDOM() {
-    const picker = document.createElement('input')
-    pickerState.set(picker, this.state)
-    picker.type = 'color'
-    picker.value = this.color
-
-    const wrapper = document.createElement('span')
-    wrapper.appendChild(picker)
-    wrapper.className = wrapperClassName
-
-    return wrapper
-  }
-
-  ignoreEvent() {
-    return false
-  }
-}
-
-export const colorPickerTheme = EditorView.baseTheme({
-  [`.${wrapperClassName}`]: {
-    display: 'inline-block',
-    outline: '1px solid #eee',
-    marginRight: '0.6ch',
-    height: '1em',
-    width: '1em',
-    transform: 'translateY(1px)',
-  },
-  [`.${wrapperClassName} input[type="color"]`]: {
-    cursor: 'pointer',
-    height: '100%',
-    width: '100%',
-    padding: 0,
-    border: 'none',
-    '&::-webkit-color-swatch-wrapper': {
-      padding: 0,
-    },
-    '&::-webkit-color-swatch': {
-      border: 'none',
-    },
-    '&::-moz-color-swatch': {
-      border: 'none',
-    },
-  },
-})
-
-interface IFactoryOptions {
-  discoverColors: typeof discoverColorsInKCL
-}
-
-export const makeColorPicker = (options: IFactoryOptions) =>
-  ViewPlugin.fromClass(
-    class ColorPickerViewPlugin {
-      decorations: DecorationSet
-
-      constructor(view: EditorView) {
-        this.decorations = colorPickersDecorations(view, options.discoverColors)
-      }
-
-      update(update: ViewUpdate) {
-        if (update.docChanged || update.viewportChanged) {
-          this.decorations = colorPickersDecorations(
-            update.view,
-            options.discoverColors
-          )
-        }
-      }
-    },
-    {
-      decorations: (v) => v.decorations,
-      eventHandlers: {
-        change: (e, view) => {
-          const target = e.target as HTMLInputElement
-          if (
-            target.nodeName !== 'INPUT' ||
-            !target.parentElement ||
-            !target.parentElement.classList.contains(wrapperClassName)
-          ) {
-            return false
-          }
-
-          const data = pickerState.get(target)!
-
-          let converted = '"' + target.value + data.alpha + '"'
-
-          view.dispatch({
-            changes: {
-              from: data.from,
-              to: data.to,
-              insert: converted,
-            },
-          })
-
-          return true
-        },
-      },
-    }
-  )
-
-export const colorPicker: Extension = [
-  makeColorPicker({ discoverColors: discoverColorsInKCL }),
-  colorPickerTheme,
-]

src/editor/plugins/lsp/kcl/language.ts

@@ -17,7 +17,6 @@ import { kclPlugin } from '.'
 import type * as LSP from 'vscode-languageserver-protocol'
 // @ts-ignore: No types available
 import { parser } from './kcl.grammar'
-import { colorPicker } from './colors'
 
 export interface LanguageOptions {
   workspaceFolders: LSP.WorkspaceFolder[]
@@ -55,14 +54,14 @@ export const KclLanguage = LRLanguage.define({
 })
 
 export function kcl(options: LanguageOptions) {
-  return new LanguageSupport(KclLanguage, [
-    colorPicker,
+  return new LanguageSupport(
+    KclLanguage,
     kclPlugin({
       documentUri: options.documentUri,
       workspaceFolders: options.workspaceFolders,
       allowHTMLContent: true,
       client: options.client,
       processLspNotification: options.processLspNotification,
-    }),
-  ])
+    })
+  )
 }

src/editor/plugins/lsp/types.ts

@@ -1,5 +1,7 @@
 import { LspWorkerEventType } from '@kittycad/codemirror-lsp-client'
 
+import { UnitLength } from 'wasm-lib/kcl/bindings/UnitLength'
+
 export enum LspWorker {
   Kcl = 'kcl',
   Copilot = 'copilot',
@@ -7,6 +9,7 @@ export enum LspWorker {
 export interface KclWorkerOptions {
   wasmUrl: string
   token: string
+  baseUnit: UnitLength
   apiBaseUrl: string
 }
 

src/editor/plugins/lsp/worker.ts

@@ -17,6 +17,7 @@ import {
   KclWorkerOptions,
   CopilotWorkerOptions,
 } from 'editor/plugins/lsp/types'
+import { EngineCommandManager } from 'lang/std/engineConnection'
 import { err, reportRejection } from 'lib/trap'
 
 const intoServer: IntoServer = new IntoServer()
@@ -45,12 +46,14 @@ export async function copilotLspRun(
 
 export async function kclLspRun(
   config: ServerConfig,
+  engineCommandManager: EngineCommandManager | null,
   token: string,
+  baseUnit: string,
   baseUrl: string
 ) {
   try {
     console.log('start kcl lsp')
-    await kcl_lsp_run(config, null, undefined, token, baseUrl)
+    await kcl_lsp_run(config, engineCommandManager, baseUnit, token, baseUrl)
   } catch (e: any) {
     console.log('kcl lsp failed', e)
     // We can't restart here because a moved value, we should do this another way.
@@ -79,7 +82,13 @@ onmessage = function (event: MessageEvent) {
           switch (worker) {
             case LspWorker.Kcl:
               const kclData = eventData as KclWorkerOptions
-              await kclLspRun(config, kclData.token, kclData.apiBaseUrl)
+              await kclLspRun(
+                config,
+                null,
+                kclData.token,
+                kclData.baseUnit,
+                kclData.apiBaseUrl
+              )
               break
             case LspWorker.Copilot:
               let copilotData = eventData as CopilotWorkerOptions

src/hooks/useSetupEngineManager.ts

@@ -2,7 +2,7 @@ import { useLayoutEffect, useEffect, useRef } from 'react'
 import { engineCommandManager, kclManager } from 'lib/singletons'
 import { deferExecution } from 'lib/utils'
 import { Themes } from 'lib/theme'
-import { makeDefaultPlanes } from 'lang/wasm'
+import { makeDefaultPlanes, modifyGrid } from 'lang/wasm'
 import { useModelingContext } from './useModelingContext'
 import { useNetworkContext } from 'hooks/useNetworkContext'
 import { useAppState, useAppStream } from 'AppState'
@@ -56,6 +56,9 @@ export function useSetupEngineManager(
       makeDefaultPlanes: () => {
         return makeDefaultPlanes(kclManager.engineCommandManager)
       },
+      modifyGrid: (hidden: boolean) => {
+        return modifyGrid(kclManager.engineCommandManager, hidden)
+      },
     })
     hasSetNonZeroDimensions.current = true
   }

src/hooks/useToolbarGuards.ts

@@ -24,8 +24,6 @@ export function useConvertToVariable(range?: SourceRange) {
   }, [enable])
 
   useEffect(() => {
-    // Return early if there are no selection ranges for whatever reason
-    if (!context.selectionRanges) return
     const parsed = ast
 
     const meta = isNodeSafeToReplace(

src/index.css

@@ -317,8 +317,3 @@ code {
 #code-mirror-override .cm-editor {
   height: 100% !important;
 }
-
-/* Can't use #code-mirror-override here as we're outside of this div */
-.body-bg .cm-diagnosticAction {
-  @apply bg-primary;
-}

src/lang/KclSingleton.ts

@@ -311,6 +311,8 @@ export class KclManager {
     // Do not send send scene commands if the program was interrupted, go to clean up
     if (!isInterrupted) {
       this.addDiagnostics(await lintAst({ ast: ast }))
+
+      sceneInfra.modelingSend({ type: 'code edit during sketch' })
       setSelectionFilterToDefault(execState.memory, this.engineCommandManager)
 
       if (args.zoomToFit) {
@@ -356,11 +358,7 @@ export class KclManager {
       this.lastSuccessfulProgramMemory = execState.memory
     }
     this.ast = { ...ast }
-    // updateArtifactGraph relies on updated executeState/programMemory
-    await this.engineCommandManager.updateArtifactGraph(this.ast)
     this._executeCallback()
-    if (!isInterrupted)
-      sceneInfra.modelingSend({ type: 'code edit during sketch' })
     this.engineCommandManager.addCommandLog({
       type: 'execution-done',
       data: null,
@@ -402,7 +400,6 @@ export class KclManager {
 
     this._logs = logs
     this.addDiagnostics(kclErrorsToDiagnostics(errors))
-
     this._execState = execState
     this._programMemory = execState.memory
     if (!errors.length) {
@@ -414,7 +411,7 @@ export class KclManager {
     // problem this solves, but either way we should strive to remove it.
     Array.from(this.engineCommandManager.artifactGraph).forEach(
       ([commandId, artifact]) => {
-        if (!('codeRef' in artifact && artifact.codeRef)) return
+        if (!('codeRef' in artifact)) return
         const _node1 = getNodeFromPath<Node<CallExpression>>(
           this.ast,
           artifact.codeRef.pathToNode,

src/lang/langHelpers.ts

@@ -1,6 +1,6 @@
 import {
   Program,
-  executor,
+  _executor,
   ProgramMemory,
   kclLint,
   emptyExecState,
@@ -64,9 +64,12 @@ export async function executeAst({
   try {
     const execState = await (programMemoryOverride
       ? enginelessExecutor(ast, programMemoryOverride)
-      : executor(ast, engineCommandManager))
+      : _executor(ast, engineCommandManager))
+
+    await engineCommandManager.waitForAllCommands(
+      programMemoryOverride !== undefined
+    )
 
-    await engineCommandManager.waitForAllCommands()
     return {
       logs: [],
       errors: [],

src/lang/modifyAst.test.ts

@@ -16,7 +16,6 @@ import {
   deleteSegmentFromPipeExpression,
   removeSingleConstraintInfo,
   deleteFromSelection,
-  splitPipedProfile,
 } from './modifyAst'
 import { enginelessExecutor } from '../lib/testHelpers'
 import { findUsesOfTagInPipe, getNodePathFromSourceRange } from './queryAst'
@@ -919,63 +918,3 @@ sketch002 = startSketchOn({
     }
   )
 })
-
-describe('Testing splitPipedProfile', () => {
-  it('should split the pipe expression correctly', () => {
-    const codeBefore = `part001 = startSketchOn('XZ')
-  |> startProfileAt([1, 2], %)
-  |> line([3, 4], %)
-  |> line([5, 6], %)
-  |> close(%)
-extrude001 = extrude(5, part001)
-    `
-
-    const expectedCodeAfter = `sketch001 = startSketchOn('XZ')
-part001 = startProfileAt([1, 2], sketch001)
-  |> line([3, 4], %)
-  |> line([5, 6], %)
-  |> close(%)
-extrude001 = extrude(5, part001)
-    `
-
-    const ast = assertParse(codeBefore)
-
-    const codeOfInterest = `startSketchOn('XZ')`
-    const range: [number, number, boolean] = [
-      codeBefore.indexOf(codeOfInterest),
-      codeBefore.indexOf(codeOfInterest) + codeOfInterest.length,
-      true,
-    ]
-    const pathToPipe = getNodePathFromSourceRange(ast, range)
-
-    const result = splitPipedProfile(ast, pathToPipe)
-
-    if (err(result)) throw result
-
-    const newCode = recast(result.modifiedAst)
-    if (err(newCode)) throw newCode
-    expect(newCode.trim()).toBe(expectedCodeAfter.trim())
-  })
-  it('should return error for already split pipe', () => {
-    const codeBefore = `sketch001 = startSketchOn('XZ')
-part001 = startProfileAt([1, 2], sketch001)
-  |> line([3, 4], %)
-  |> line([5, 6], %)
-  |> close(%)
-extrude001 = extrude(5, part001)
-    `
-
-    const ast = assertParse(codeBefore)
-
-    const codeOfInterest = `startProfileAt([1, 2], sketch001)`
-    const range: [number, number, boolean] = [
-      codeBefore.indexOf(codeOfInterest),
-      codeBefore.indexOf(codeOfInterest) + codeOfInterest.length,
-      true,
-    ]
-    const pathToPipe = getNodePathFromSourceRange(ast, range)
-
-    const result = splitPipedProfile(ast, pathToPipe)
-    expect(result instanceof Error).toBe(true)
-  })
-})

src/lang/modifyAst.ts

@@ -29,8 +29,6 @@ import {
   getNodePathFromSourceRange,
   isNodeSafeToReplace,
   traverse,
-  getBodyIndex,
-  isCallExprWithName,
 } from './queryAst'
 import { addTagForSketchOnFace, getConstraintInfo } from './std/sketch'
 import {
@@ -47,8 +45,6 @@ import { TagDeclarator } from 'wasm-lib/kcl/bindings/TagDeclarator'
 import { Models } from '@kittycad/lib'
 import { ExtrudeFacePlane } from 'machines/modelingMachine'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
-import { KclExpressionWithVariable } from 'lib/commandTypes'
-import { Artifact, getPathsFromArtifact } from './std/artifactGraph'
 
 export function startSketchOnDefault(
   node: Node<Program>,
@@ -81,54 +77,41 @@ export function startSketchOnDefault(
   }
 }
 
-export function insertNewStartProfileAt(
+export function addStartProfileAt(
   node: Node<Program>,
-  sketchEntryNodePath: PathToNode,
-  sketchNodePaths: PathToNode[],
-  planeNodePath: PathToNode,
-  at: [number, number],
-  insertType: 'start' | 'end' = 'end'
-):
-  | {
-      modifiedAst: Node<Program>
-      updatedSketchNodePaths: PathToNode[]
-      updatedEntryNodePath: PathToNode
-    }
-  | Error {
-  const varDec = getNodeFromPath<VariableDeclarator>(
+  pathToNode: PathToNode,
+  at: [number, number]
+): { modifiedAst: Node<Program>; pathToNode: PathToNode } | Error {
+  const _node1 = getNodeFromPath<VariableDeclaration>(
     node,
-    planeNodePath,
-    'VariableDeclarator'
+    pathToNode,
+    'VariableDeclaration'
   )
-  if (err(varDec)) return varDec
-  if (varDec.node.type !== 'VariableDeclarator') return new Error('not a var')
-
-  const newExpression = createVariableDeclaration(
-    findUniqueName(node, 'profile'),
-    createCallExpressionStdLib('startProfileAt', [
-      createArrayExpression([
-        createLiteral(roundOff(at[0])),
-        createLiteral(roundOff(at[1])),
-      ]),
-      createIdentifier(varDec.node.id.name),
+  if (err(_node1)) return _node1
+  const variableDeclaration = _node1.node
+  if (variableDeclaration.type !== 'VariableDeclaration') {
+    return new Error('variableDeclaration.init.type !== PipeExpression')
+  }
+  const _node = { ...node }
+  const init = variableDeclaration.declaration.init
+  const startProfileAt = createCallExpressionStdLib('startProfileAt', [
+    createArrayExpression([
+      createLiteral(roundOff(at[0])),
+      createLiteral(roundOff(at[1])),
+    ]),
+    createPipeSubstitution(),
+  ])
+  if (init.type === 'PipeExpression') {
+    init.body.splice(1, 0, startProfileAt)
+  } else {
+    variableDeclaration.declaration.init = createPipeExpression([
+      init,
+      startProfileAt,
     ])
-  )
-  const insertIndex = getInsertIndex(sketchNodePaths, planeNodePath, insertType)
-
-  const _node = structuredClone(node)
-  // TODO the rest of this function will not be robust to work for sketches defined within a function declaration
-  _node.body.splice(insertIndex, 0, newExpression)
-
-  const { updatedEntryNodePath, updatedSketchNodePaths } =
-    updateSketchNodePathsWithInsertIndex({
-      insertIndex,
-      insertType,
-      sketchNodePaths,
-    })
+  }
   return {
     modifiedAst: _node,
-    updatedSketchNodePaths,
-    updatedEntryNodePath,
+    pathToNode,
   }
 }
 
@@ -269,7 +252,7 @@ export function mutateObjExpProp(
 export function extrudeSketch(
   node: Node<Program>,
   pathToNode: PathToNode,
-  artifact?: Artifact,
+  shouldPipe = false,
   distance: Expr = createLiteral(4)
 ):
   | {
@@ -278,14 +261,10 @@ export function extrudeSketch(
       pathToExtrudeArg: PathToNode
     }
   | Error {
-  const orderedSketchNodePaths = getPathsFromArtifact({
-    artifact: artifact,
-    sketchPathToNode: pathToNode,
-  })
-  if (err(orderedSketchNodePaths)) return orderedSketchNodePaths
   const _node = structuredClone(node)
   const _node1 = getNodeFromPath(_node, pathToNode)
   if (err(_node1)) return _node1
+  const { node: sketchExpression } = _node1
 
   // determine if sketchExpression is in a pipeExpression or not
   const _node2 = getNodeFromPath<PipeExpression>(
@@ -294,6 +273,9 @@ export function extrudeSketch(
     'PipeExpression'
   )
   if (err(_node2)) return _node2
+  const { node: pipeExpression } = _node2
+
+  const isInPipeExpression = pipeExpression.type === 'PipeExpression'
 
   const _node3 = getNodeFromPath<VariableDeclarator>(
     _node,
@@ -301,23 +283,49 @@ export function extrudeSketch(
     'VariableDeclarator'
   )
   if (err(_node3)) return _node3
-  const { node: variableDeclarator } = _node3
+  const { node: variableDeclarator, shallowPath: pathToDecleration } = _node3
 
   const extrudeCall = createCallExpressionStdLib('extrude', [
     distance,
-    createIdentifier(variableDeclarator.id.name),
+    shouldPipe
+      ? createPipeSubstitution()
+      : createIdentifier(variableDeclarator.id.name),
   ])
 
+  if (shouldPipe) {
+    const pipeChain = createPipeExpression(
+      isInPipeExpression
+        ? [...pipeExpression.body, extrudeCall]
+        : [sketchExpression as any, extrudeCall]
+    )
+
+    variableDeclarator.init = pipeChain
+    const pathToExtrudeArg: PathToNode = [
+      ...pathToDecleration,
+      ['init', 'VariableDeclarator'],
+      ['body', ''],
+      [pipeChain.body.length - 1, 'index'],
+      ['arguments', 'CallExpression'],
+      [0, 'index'],
+    ]
+
+    return {
+      modifiedAst: _node,
+      pathToNode,
+      pathToExtrudeArg,
+    }
+  }
+
   // We're not creating a pipe expression,
   // but rather a separate constant for the extrusion
   const name = findUniqueName(node, KCL_DEFAULT_CONSTANT_PREFIXES.EXTRUDE)
   const VariableDeclaration = createVariableDeclaration(name, extrudeCall)
 
-  const lastSketchNodePath =
-    orderedSketchNodePaths[orderedSketchNodePaths.length - 1]
-
-  console.log('lastSketchNodePath', lastSketchNodePath, orderedSketchNodePaths)
-  const sketchIndexInBody = Number(lastSketchNodePath[1][0])
+  const sketchIndexInPathToNode =
+    pathToDecleration.findIndex((a) => a[0] === 'body') + 1
+  const sketchIndexInBody = pathToDecleration[
+    sketchIndexInPathToNode
+  ][0] as number
   _node.body.splice(sketchIndexInBody + 1, 0, VariableDeclaration)
 
   const pathToExtrudeArg: PathToNode = [
@@ -582,25 +590,6 @@ export function addOffsetPlane({
   }
 }
 
-/**
- * Return a modified clone of an AST with a named constant inserted into the body
- */
-export function insertNamedConstant({
-  node,
-  newExpression,
-}: {
-  node: Node<Program>
-  newExpression: KclExpressionWithVariable
-}): Node<Program> {
-  const ast = structuredClone(node)
-  ast.body.splice(
-    newExpression.insertIndex,
-    0,
-    newExpression.variableDeclarationAst
-  )
-  return ast
-}
-
 /**
  * Modify the AST to create a new sketch using the variable declaration
  * of an offset plane. The new sketch just has to come after the offset
@@ -944,31 +933,6 @@ export function giveSketchFnCallTag(
   }
 }
 
-/**
- * Replace a
- */
-export function replaceValueAtNodePath({
-  ast,
-  pathToNode,
-  newExpressionString,
-}: {
-  ast: Node<Program>
-  pathToNode: PathToNode
-  newExpressionString: string
-}) {
-  const replaceCheckResult = isNodeSafeToReplacePath(ast, pathToNode)
-  if (err(replaceCheckResult)) {
-    return replaceCheckResult
-  }
-  const { isSafe, value, replacer } = replaceCheckResult
-
-  if (!isSafe || value.type === 'Identifier') {
-    return new Error('Not safe to replace')
-  }
-
-  return replacer(ast, newExpressionString)
-}
-
 export function moveValueIntoNewVariablePath(
   ast: Node<Program>,
   programMemory: ProgramMemory,
@@ -1286,8 +1250,7 @@ export async function deleteFromSelection(
     const pipeBody = varDec.node.init.body
     if (
       pipeBody[0].type === 'CallExpression' &&
-      (pipeBody[0].callee.name === 'startSketchOn' ||
-        pipeBody[0].callee.name === 'startProfileAt')
+      pipeBody[0].callee.name === 'startSketchOn'
     ) {
       // remove varDec
       const varDecIndex = varDec.shallowPath[1][0] as number
@@ -1302,149 +1265,3 @@ export async function deleteFromSelection(
 const nonCodeMetaEmpty = () => {
   return { nonCodeNodes: {}, startNodes: [], start: 0, end: 0 }
 }
-
-export function getInsertIndex(
-  sketchNodePaths: PathToNode[],
-  planeNodePath: PathToNode,
-  insertType: 'start' | 'end'
-) {
-  let minIndex = 0
-  let maxIndex = 0
-  for (const path of sketchNodePaths) {
-    const index = Number(path[1][0])
-    if (index < minIndex) minIndex = index
-    if (index > maxIndex) maxIndex = index
-  }
-
-  const insertIndex = !sketchNodePaths.length
-    ? Number(planeNodePath[1][0]) + 1
-    : insertType === 'start'
-    ? minIndex
-    : maxIndex + 1
-  return insertIndex
-}
-
-export function updateSketchNodePathsWithInsertIndex({
-  insertIndex,
-  insertType,
-  sketchNodePaths,
-}: {
-  insertIndex: number
-  insertType: 'start' | 'end'
-  sketchNodePaths: PathToNode[]
-}): {
-  updatedEntryNodePath: PathToNode
-  updatedSketchNodePaths: PathToNode[]
-} {
-  // TODO the rest of this function will not be robust to work for sketches defined within a function declaration
-  const newExpressionPathToNode: PathToNode = [
-    ['body', ''],
-    [insertIndex, 'index'],
-    ['declaration', 'VariableDeclaration'],
-    ['init', 'VariableDeclarator'],
-  ]
-  let updatedSketchNodePaths = structuredClone(sketchNodePaths)
-  if (insertType === 'start') {
-    updatedSketchNodePaths = updatedSketchNodePaths.map((path) => {
-      path[1][0] = Number(path[1][0]) + 1
-      return path
-    })
-    updatedSketchNodePaths.unshift(newExpressionPathToNode)
-  } else {
-    updatedSketchNodePaths.push(newExpressionPathToNode)
-  }
-  return {
-    updatedSketchNodePaths,
-    updatedEntryNodePath: newExpressionPathToNode,
-  }
-}
-
-/**
- * 
- * Split the following pipe expression into 
- * ```ts
- * part001 = startSketchOn('XZ')
-  |> startProfileAt([1, 2], %)
-  |> line([3, 4], %)
-  |> line([5, 6], %)
-  |> close(%)
-extrude001 = extrude(5, part001)
-```
-into
-```ts
-sketch001 = startSketchOn('XZ')
-part001 = startProfileAt([1, 2], sketch001)
-  |> line([3, 4], %)
-  |> line([5, 6], %)
-  |> close(%)
-extrude001 = extrude(5, part001)
-```
-Notice that the `startSketchOn` is what gets the new variable name, this is so part001 still has the same data as before
-making it safe for later code that uses part001 (the extrude in this example)
- * 
- */
-export function splitPipedProfile(
-  ast: Program,
-  pathToPipe: PathToNode
-):
-  | {
-      modifiedAst: Program
-      pathToProfile: PathToNode
-      pathToPlane: PathToNode
-    }
-  | Error {
-  const _ast = structuredClone(ast)
-  const varDec = getNodeFromPath<VariableDeclaration>(
-    _ast,
-    pathToPipe,
-    'VariableDeclaration'
-  )
-  if (err(varDec)) return varDec
-  if (
-    varDec.node.type !== 'VariableDeclaration' ||
-    varDec.node.declaration.init.type !== 'PipeExpression'
-  ) {
-    return new Error('pathToNode does not point to pipe')
-  }
-  const init = varDec.node.declaration.init
-  const firstCall = init.body[0]
-  if (!isCallExprWithName(firstCall, 'startSketchOn'))
-    return new Error('First call is not startSketchOn')
-  const secondCall = init.body[1]
-  if (!isCallExprWithName(secondCall, 'startProfileAt'))
-    return new Error('Second call is not startProfileAt')
-
-  const varName = varDec.node.declaration.id.name
-  const newVarName = findUniqueName(_ast, 'sketch')
-  const secondCallArgs = structuredClone(secondCall.arguments)
-  secondCallArgs[1] = createIdentifier(newVarName)
-  const firstCallOfNewPipe = createCallExpression(
-    'startProfileAt',
-    secondCallArgs
-  )
-  const newSketch = createVariableDeclaration(
-    newVarName,
-    varDec.node.declaration.init.body[0]
-  )
-  const newProfile = createVariableDeclaration(
-    varName,
-    varDec.node.declaration.init.body.length <= 2
-      ? firstCallOfNewPipe
-      : createPipeExpression([
-          firstCallOfNewPipe,
-          ...varDec.node.declaration.init.body.slice(2),
-        ])
-  )
-  const index = getBodyIndex(pathToPipe)
-  if (err(index)) return index
-  _ast.body.splice(index, 1, newSketch, newProfile)
-  const pathToPlane = structuredClone(pathToPipe)
-  const pathToProfile = structuredClone(pathToPipe)
-  pathToProfile[1][0] = index + 1
-
-  return {
-    modifiedAst: _ast,
-    pathToProfile,
-    pathToPlane,
-  }
-}

src/lang/modifyAst/addEdgeTreatment.test.ts

@@ -40,6 +40,7 @@ beforeAll(async () => {
       makeDefaultPlanes: () => makeDefaultPlanes(engineCommandManager),
       setMediaStream: () => {},
       setIsStreamReady: () => {},
+      modifyGrid: async () => {},
       callbackOnEngineLiteConnect: () => {
         resolve(true)
       },
@@ -275,7 +276,7 @@ const runModifyAstCloneWithEdgeTreatmentAndTag = async (
   const selection: Selections = {
     graphSelections: segmentRanges.map((segmentRange) => {
       const maybeArtifact = [...artifactGraph].find(([, a]) => {
-        if (!('codeRef' in a && a.codeRef)) return false
+        if (!('codeRef' in a)) return false
         return isOverlap(a.codeRef.range, segmentRange)
       })
       return {
@@ -487,8 +488,8 @@ extrude001 = extrude(-15, sketch001)
   |> lineTo([profileStartX(%), profileStartY(%)], %)
   |> close(%)
 extrude001 = extrude(-15, sketch001)
-  |> chamfer({ length = 5, tags = [seg01] }, %)
-  |> ${edgeTreatmentType}({ ${parameterName} = 3, tags = [seg02] }, %)`
+  |> chamfer({ length: 5, tags: [seg01] }, %)
+  |> ${edgeTreatmentType}({ ${parameterName}: 3, tags: [seg02] }, %)`
 
         await runModifyAstCloneWithEdgeTreatmentAndTag(
           code,

src/lang/modifyAst/addEdgeTreatment.ts

@@ -335,7 +335,7 @@ export function mutateAstWithTagForSketchSegment(
   return { modifiedAst: astClone, tag }
 }
 
-export function getEdgeTagCall(
+function getEdgeTagCall(
   tag: string,
   artifact: Artifact
 ): Node<Identifier | CallExpression> {

src/lang/modifyAst/addRevolve.ts

@@ -1,154 +0,0 @@
-import { err } from 'lib/trap'
-import { KCL_DEFAULT_CONSTANT_PREFIXES } from 'lib/constants'
-import {
-  Program,
-  PathToNode,
-  Expr,
-  CallExpression,
-  PipeExpression,
-  VariableDeclarator,
-} from 'lang/wasm'
-import { Selections } from 'lib/selections'
-import { Node } from 'wasm-lib/kcl/bindings/Node'
-import {
-  createLiteral,
-  createCallExpressionStdLib,
-  createObjectExpression,
-  createIdentifier,
-  createPipeExpression,
-  findUniqueName,
-  createVariableDeclaration,
-} from 'lang/modifyAst'
-import { getNodeFromPath, getNodePathFromSourceRange } from 'lang/queryAst'
-import {
-  mutateAstWithTagForSketchSegment,
-  getEdgeTagCall,
-} from 'lang/modifyAst/addEdgeTreatment'
-export function revolveSketch(
-  ast: Node<Program>,
-  pathToSketchNode: PathToNode,
-  shouldPipe = false,
-  angle: Expr = createLiteral(4),
-  axis: Selections
-):
-  | {
-      modifiedAst: Node<Program>
-      pathToSketchNode: PathToNode
-      pathToRevolveArg: PathToNode
-    }
-  | Error {
-  const clonedAst = structuredClone(ast)
-  const sketchNode = getNodeFromPath(clonedAst, pathToSketchNode)
-  if (err(sketchNode)) return sketchNode
-
-  // testing code
-  const pathToAxisSelection = getNodePathFromSourceRange(
-    clonedAst,
-    axis.graphSelections[0]?.codeRef.range
-  )
-
-  const lineNode = getNodeFromPath<CallExpression>(
-    clonedAst,
-    pathToAxisSelection,
-    'CallExpression'
-  )
-  if (err(lineNode)) return lineNode
-
-  // TODO Kevin: What if |> close(%)?
-  // TODO Kevin: What if opposite edge
-  // TODO Kevin: What if the edge isn't planar to the sketch?
-  // TODO Kevin: add a tag.
-  const tagResult = mutateAstWithTagForSketchSegment(
-    clonedAst,
-    pathToAxisSelection
-  )
-
-  // Have the tag whether it is already created or a new one is generated
-  if (err(tagResult)) return tagResult
-  const { tag } = tagResult
-
-  /* Original Code */
-  const { node: sketchExpression } = sketchNode
-
-  // determine if sketchExpression is in a pipeExpression or not
-  const sketchPipeExpressionNode = getNodeFromPath<PipeExpression>(
-    clonedAst,
-    pathToSketchNode,
-    'PipeExpression'
-  )
-  if (err(sketchPipeExpressionNode)) return sketchPipeExpressionNode
-  const { node: sketchPipeExpression } = sketchPipeExpressionNode
-  const isInPipeExpression = sketchPipeExpression.type === 'PipeExpression'
-
-  const sketchVariableDeclaratorNode = getNodeFromPath<VariableDeclarator>(
-    clonedAst,
-    pathToSketchNode,
-    'VariableDeclarator'
-  )
-  if (err(sketchVariableDeclaratorNode)) return sketchVariableDeclaratorNode
-  const {
-    node: sketchVariableDeclarator,
-    shallowPath: sketchPathToDecleration,
-  } = sketchVariableDeclaratorNode
-
-  const axisSelection = axis?.graphSelections[0]?.artifact
-
-  if (!axisSelection) return new Error('Axis selection is missing.')
-
-  const revolveCall = createCallExpressionStdLib('revolve', [
-    createObjectExpression({
-      angle: angle,
-      axis: getEdgeTagCall(tag, axisSelection),
-    }),
-    createIdentifier(sketchVariableDeclarator.id.name),
-  ])
-
-  if (shouldPipe) {
-    const pipeChain = createPipeExpression(
-      isInPipeExpression
-        ? [...sketchPipeExpression.body, revolveCall]
-        : [sketchExpression as any, revolveCall]
-    )
-
-    sketchVariableDeclarator.init = pipeChain
-    const pathToRevolveArg: PathToNode = [
-      ...sketchPathToDecleration,
-      ['init', 'VariableDeclarator'],
-      ['body', ''],
-      [pipeChain.body.length - 1, 'index'],
-      ['arguments', 'CallExpression'],
-      [0, 'index'],
-    ]
-
-    return {
-      modifiedAst: clonedAst,
-      pathToSketchNode,
-      pathToRevolveArg,
-    }
-  }
-
-  // We're not creating a pipe expression,
-  // but rather a separate constant for the extrusion
-  const name = findUniqueName(clonedAst, KCL_DEFAULT_CONSTANT_PREFIXES.REVOLVE)
-  const VariableDeclaration = createVariableDeclaration(name, revolveCall)
-  const sketchIndexInPathToNode =
-    sketchPathToDecleration.findIndex((a) => a[0] === 'body') + 1
-  const sketchIndexInBody = sketchPathToDecleration[sketchIndexInPathToNode][0]
-  if (typeof sketchIndexInBody !== 'number')
-    return new Error('expected sketchIndexInBody to be a number')
-  clonedAst.body.splice(sketchIndexInBody + 1, 0, VariableDeclaration)
-
-  const pathToRevolveArg: PathToNode = [
-    ['body', ''],
-    [sketchIndexInBody + 1, 'index'],
-    ['declaration', 'VariableDeclaration'],
-    ['init', 'VariableDeclarator'],
-    ['arguments', 'CallExpression'],
-    [0, 'index'],
-  ]
-  return {
-    modifiedAst: clonedAst,
-    pathToSketchNode: [...pathToSketchNode.slice(0, -1), [-1, 'index']],
-    pathToRevolveArg,
-  }
-}

src/lang/modifyAst/addShell.ts

@@ -111,7 +111,8 @@ export function addShell({
   const pathToNode: PathToNode = [
     ['body', ''],
     [modifiedAst.body.length - 1, 'index'],
-    ['declaration', 'VariableDeclaration'],
+    ['declarations', 'VariableDeclaration'],
+    ['0', 'index'],
     ['init', 'VariableDeclarator'],
     ['arguments', 'CallExpression'],
     [0, 'index'],

src/lang/queryAst.test.ts

@@ -661,7 +661,7 @@ describe('Testing doesSceneHaveExtrudedSketch', () => {
   |> circle({ center = [0, 0], radius = 1 }, %)
 extrude001 = extrude(1, sketch001)
 `
-    const ast = assertParse(exampleCode)
+    const ast = parse(exampleCode)
     if (err(ast)) throw ast
     const extrudable = doesSceneHaveExtrudedSketch(ast)
     expect(extrudable).toBeTruthy()
@@ -671,7 +671,7 @@ extrude001 = extrude(1, sketch001)
   |> circle({ center = [0, 0], radius = 1 }, %)
   |> extrude(1, %)
 `
-    const ast = assertParse(exampleCode)
+    const ast = parse(exampleCode)
     if (err(ast)) throw ast
     const extrudable = doesSceneHaveExtrudedSketch(ast)
     expect(extrudable).toBeTruthy()
@@ -680,7 +680,7 @@ extrude001 = extrude(1, sketch001)
     const exampleCode = `extrude001 = startSketchOn('XZ')
   |> circle({ center = [0, 0], radius = 1 }, %)
 `
-    const ast = assertParse(exampleCode)
+    const ast = parse(exampleCode)
     if (err(ast)) throw ast
     const extrudable = doesSceneHaveExtrudedSketch(ast)
     expect(extrudable).toBeFalsy()

src/lang/queryAst.ts

@@ -33,7 +33,6 @@ import { err, Reason } from 'lib/trap'
 import { ImportStatement } from 'wasm-lib/kcl/bindings/ImportStatement'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
 import { ArtifactGraph, codeRefFromRange } from './std/artifactGraph'
-import { FunctionExpression } from 'wasm-lib/kcl/bindings/FunctionExpression'
 
 /**
  * Retrieves a node from a given path within a Program node structure, optionally stopping at a specified node type.
@@ -597,13 +596,7 @@ export function findAllPreviousVariables(
 type ReplacerFn = (
   _ast: Node<Program>,
   varName: string
-) =>
-  | {
-      modifiedAst: Node<Program>
-      pathToReplaced: PathToNode
-      exprInsertIndex: number
-    }
-  | Error
+) => { modifiedAst: Node<Program>; pathToReplaced: PathToNode } | Error
 
 export function isNodeSafeToReplacePath(
   ast: Program,
@@ -655,7 +648,7 @@ export function isNodeSafeToReplacePath(
     if (err(_nodeToReplace)) return _nodeToReplace
     const nodeToReplace = _nodeToReplace.node as any
     nodeToReplace[last[0]] = identifier
-    return { modifiedAst: _ast, pathToReplaced, exprInsertIndex: index }
+    return { modifiedAst: _ast, pathToReplaced }
   }
 
   const hasPipeSub = isTypeInValue(finVal as Expr, 'PipeSubstitution')
@@ -774,15 +767,8 @@ export function isLinesParallelAndConstrained(
     if (err(_primarySegment)) return _primarySegment
     const primarySegment = _primarySegment.segment
 
-    const _varDec2 = getNodeFromPath(ast, secondaryPath, 'VariableDeclaration')
-    if (err(_varDec2)) return _varDec2
-    const varDec2 = _varDec2.node
-    const varName2 = (varDec2 as VariableDeclaration)?.declaration.id?.name
-    const sg2 = sketchFromKclValue(programMemory?.get(varName2), varName2)
-    if (err(sg2)) return sg2
-
     const _segment = getSketchSegmentFromSourceRange(
-      sg2,
+      sg,
       secondaryLine?.codeRef?.range
     )
     if (err(_segment)) return _segment
@@ -1058,15 +1044,13 @@ export function doesSceneHaveSweepableSketch(ast: Node<Program>, count = 1) {
             hasCircle = true
           }
         }
-        if ((hasStartProfileAt && hasClose) || hasCircle) {
+        if (
+          (hasStartProfileAt || hasCircle) &&
+          hasStartSketchOn &&
+          (hasClose || hasCircle)
+        ) {
           theMap[node.id.name] = true
         }
-      } else if (
-        node.type === 'VariableDeclaration' &&
-        node.declaration.init.type === 'CallExpression' &&
-        node.declaration.init.callee.name === 'circle'
-      ) {
-        theMap[node.declaration.id.name] = true
       } else if (
         node.type === 'CallExpression' &&
         (node.callee.name === 'extrude' || node.callee.name === 'revolve') &&
@@ -1117,57 +1101,3 @@ export function getObjExprProperty(
   if (index === -1) return null
   return { expr: node.properties[index].value, index }
 }
-
-export function isCursorInFunctionDefinition(
-  ast: Node<Program>,
-  selectionRanges: Selection
-): boolean {
-  if (!selectionRanges?.codeRef?.pathToNode) return false
-  const node = getNodeFromPath<FunctionExpression>(
-    ast,
-    selectionRanges.codeRef.pathToNode,
-    'FunctionExpression'
-  )
-  if (err(node)) return false
-  if (node.node.type === 'FunctionExpression') return true
-  return false
-}
-
-export function getBodyIndex(pathToNode: PathToNode): number | Error {
-  const index = Number(pathToNode[1][0])
-  if (Number.isInteger(index)) return index
-  return new Error('Expected number index')
-}
-
-export function isCallExprWithName(
-  expr: Expr | CallExpression,
-  name: string
-): expr is CallExpression {
-  if (expr.type === 'CallExpression' && expr.callee.type === 'Identifier') {
-    return expr.callee.name === name
-  }
-  return false
-}
-
-export function doesSketchPipeNeedSplitting(
-  ast: Node<Program>,
-  pathToPipe: PathToNode
-): boolean | Error {
-  const varDec = getNodeFromPath<VariableDeclarator>(
-    ast,
-    pathToPipe,
-    'VariableDeclarator'
-  )
-  if (err(varDec)) return varDec
-  if (varDec.node.type !== 'VariableDeclarator') return new Error('Not a var')
-  const pipeExpression = varDec.node.init
-  if (pipeExpression.type !== 'PipeExpression') return false
-  const [firstPipe, secondPipe] = pipeExpression.body
-  if (!firstPipe || !secondPipe) return false
-  if (
-    isCallExprWithName(firstPipe, 'startSketchOn') &&
-    isCallExprWithName(secondPipe, 'startProfileAt')
-  )
-    return true
-  return false
-}

src/lang/std/__snapshots__/artifactGraph.test.ts.snap

@@ -212,19 +212,6 @@ Map {
     "type": "wall",
   },
   "UUID-10" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        501,
-        522,
-        0,
-      ],
-    },
     "edgeCutEdgeIds": [],
     "id": "UUID",
     "pathIds": [

src/lang/std/artifactGraph.test.ts

@@ -139,6 +139,7 @@ beforeAll(async () => {
       makeDefaultPlanes: () => makeDefaultPlanes(engineCommandManager),
       setMediaStream: () => {},
       setIsStreamReady: () => {},
+      modifyGrid: async () => {},
       // eslint-disable-next-line @typescript-eslint/no-misused-promises
       callbackOnEngineLiteConnect: async () => {
         const cacheEntries = Object.entries(codeToWriteCacheFor) as [

src/lang/std/artifactGraph.ts

@@ -1,8 +1,7 @@
-import { Expr, PathToNode, Program, SourceRange } from 'lang/wasm'
+import { PathToNode, Program, SourceRange } from 'lang/wasm'
 import { Models } from '@kittycad/lib'
 import { getNodePathFromSourceRange } from 'lang/queryAst'
 import { err } from 'lib/trap'
-import { engineCommandManager, kclManager } from 'lib/singletons'
 
 export type ArtifactId = string
 
@@ -35,7 +34,7 @@ export interface PathArtifact extends BaseArtifact {
   codeRef: CodeRef
 }
 
-interface Solid2DArtifact extends BaseArtifact {
+interface solid2D extends BaseArtifact {
   type: 'solid2D'
   pathId: ArtifactId
 }
@@ -62,7 +61,7 @@ interface SegmentArtifactRich extends BaseArtifact {
   type: 'segment'
   path: PathArtifact
   surf: WallArtifact
-  edges: Array<SweepEdgeArtifact>
+  edges: Array<SweepEdge>
   edgeCut?: EdgeCut
   codeRef: CodeRef
 }
@@ -81,7 +80,7 @@ interface SweepArtifactRich extends BaseArtifact {
   subType: 'extrusion' | 'revolve'
   path: PathArtifact
   surfaces: Array<WallArtifact | CapArtifact>
-  edges: Array<SweepEdgeArtifact>
+  edges: Array<SweepEdge>
   codeRef: CodeRef
 }
 
@@ -91,9 +90,6 @@ interface WallArtifact extends BaseArtifact {
   edgeCutEdgeIds: Array<ArtifactId>
   sweepId: ArtifactId
   pathIds: Array<ArtifactId>
-  // codeRef is for the sketchOnFace plane, not for the wall itself
-  // traverse to the extrude and or segment to get the wall's codeRef
-  codeRef?: CodeRef
 }
 interface CapArtifact extends BaseArtifact {
   type: 'cap'
@@ -103,7 +99,7 @@ interface CapArtifact extends BaseArtifact {
   pathIds: Array<ArtifactId>
 }
 
-interface SweepEdgeArtifact extends BaseArtifact {
+interface SweepEdge extends BaseArtifact {
   type: 'sweepEdge'
   segId: ArtifactId
   sweepId: ArtifactId
@@ -133,10 +129,10 @@ export type Artifact =
   | SweepArtifact
   | WallArtifact
   | CapArtifact
-  | SweepEdgeArtifact
+  | SweepEdge
   | EdgeCut
   | EdgeCutEdge
-  | Solid2DArtifact
+  | solid2D
 
 export type ArtifactGraph = Map<ArtifactId, Artifact>
 
@@ -288,7 +284,6 @@ export function getArtifactsToUpdate({
             edgeCutEdgeIds: existingPlane.edgeCutEdgeIds,
             sweepId: existingPlane.sweepId,
             pathIds: existingPlane.pathIds,
-            codeRef,
           },
         },
       ]
@@ -738,7 +733,7 @@ export function getCapCodeRef(
 }
 
 export function getSolid2dCodeRef(
-  solid2D: Solid2DArtifact,
+  solid2D: solid2D,
   artifactGraph: ArtifactGraph
 ): CodeRef | Error {
   const path = getArtifactOfTypes(
@@ -762,7 +757,7 @@ export function getWallCodeRef(
 }
 
 export function getSweepEdgeCodeRef(
-  edge: SweepEdgeArtifact,
+  edge: SweepEdge,
   artifactGraph: ArtifactGraph
 ): CodeRef | Error {
   const seg = getArtifactOfTypes(
@@ -876,202 +871,3 @@ export function codeRefFromRange(range: SourceRange, ast: Program): CodeRef {
     pathToNode: getNodePathFromSourceRange(ast, range),
   }
 }
-
-function getPlaneFromPath(
-  path: PathArtifact,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  const plane = getArtifactOfTypes(
-    { key: path.planeId, types: ['plane', 'wall'] },
-    graph
-  )
-  if (err(plane)) return plane
-  return plane
-}
-
-function getPlaneFromSegment(
-  segment: SegmentArtifact,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  const path = getArtifactOfTypes(
-    { key: segment.pathId, types: ['path'] },
-    graph
-  )
-  if (err(path)) return path
-  return getPlaneFromPath(path, graph)
-}
-function getPlaneFromSolid2D(
-  solid2D: Solid2DArtifact,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  const path = getArtifactOfTypes(
-    { key: solid2D.pathId, types: ['path'] },
-    graph
-  )
-  if (err(path)) return path
-  return getPlaneFromPath(path, graph)
-}
-function getPlaneFromCap(
-  cap: CapArtifact,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  const sweep = getArtifactOfTypes(
-    { key: cap.sweepId, types: ['sweep'] },
-    graph
-  )
-  if (err(sweep)) return sweep
-  const path = getArtifactOfTypes({ key: sweep.pathId, types: ['path'] }, graph)
-  if (err(path)) return path
-  return getPlaneFromPath(path, graph)
-}
-function getPlaneFromWall(
-  wall: WallArtifact,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  const sweep = getArtifactOfTypes(
-    { key: wall.sweepId, types: ['sweep'] },
-    graph
-  )
-  if (err(sweep)) return sweep
-  const path = getArtifactOfTypes({ key: sweep.pathId, types: ['path'] }, graph)
-  if (err(path)) return path
-  return getPlaneFromPath(path, graph)
-}
-function getPlaneFromSweepEdge(edge: SweepEdgeArtifact, graph: ArtifactGraph) {
-  const sweep = getArtifactOfTypes(
-    { key: edge.sweepId, types: ['sweep'] },
-    graph
-  )
-  if (err(sweep)) return sweep
-  const path = getArtifactOfTypes({ key: sweep.pathId, types: ['path'] }, graph)
-  if (err(path)) return path
-  return getPlaneFromPath(path, graph)
-}
-
-export function getPlaneFromArtifact(
-  artifact: Artifact | undefined,
-  graph: ArtifactGraph
-): PlaneArtifact | WallArtifact | Error {
-  if (!artifact) return new Error(`Artifact is undefined`)
-  if (artifact.type === 'plane') return artifact
-  if (artifact.type === 'path') return getPlaneFromPath(artifact, graph)
-  if (artifact.type === 'segment') return getPlaneFromSegment(artifact, graph)
-  if (artifact.type === 'solid2D') return getPlaneFromSolid2D(artifact, graph)
-  if (artifact.type === 'cap') return getPlaneFromCap(artifact, graph)
-  if (artifact.type === 'wall') return getPlaneFromWall(artifact, graph)
-  if (artifact.type === 'sweepEdge')
-    return getPlaneFromSweepEdge(artifact, graph)
-  return new Error(`Artifact type ${artifact.type} does not have a plane`)
-}
-
-const isExprSafe = (index: number): boolean => {
-  const expr = kclManager.ast.body?.[index]
-  if (!expr) {
-    return false
-  }
-  if (expr.type === 'ImportStatement' || expr.type === 'ReturnStatement') {
-    return false
-  }
-  if (expr.type === 'VariableDeclaration') {
-    const init = expr.declaration?.init
-    if (!init) return false
-    if (init.type === 'CallExpression') {
-      return false
-    }
-    if (init.type === 'BinaryExpression' && isNodeSafe(init)) {
-      return true
-    }
-    if (init.type === 'Literal' || init.type === 'MemberExpression') {
-      return true
-    }
-  }
-  return false
-}
-
-const onlyConsecutivePaths = (
-  orderedNodePaths: PathToNode[],
-  originalPath: PathToNode
-): PathToNode[] => {
-  const originalIndex = Number(
-    orderedNodePaths.find(
-      (path) => path[1][0] === originalPath[1][0]
-    )?.[1]?.[0] || 0
-  )
-
-  const minIndex = Number(orderedNodePaths[0][1][0])
-  const maxIndex = Number(orderedNodePaths[orderedNodePaths.length - 1][1][0])
-  const pathIndexMap: any = {}
-  orderedNodePaths.forEach((path) => {
-    const bodyIndex = Number(path[1][0])
-    pathIndexMap[bodyIndex] = path
-  })
-  const safePaths: PathToNode[] = []
-
-  // traverse expressions in either direction from the profile selected
-  // when the user entered sketch mode
-  for (let i = originalIndex; i <= maxIndex; i++) {
-    if (pathIndexMap[i]) {
-      safePaths.push(pathIndexMap[i])
-    } else if (!isExprSafe(i)) {
-      break
-    }
-  }
-  for (let i = originalIndex - 1; i >= minIndex; i--) {
-    if (pathIndexMap[i]) {
-      safePaths.unshift(pathIndexMap[i])
-    } else if (!isExprSafe(i)) {
-      break
-    }
-  }
-  return safePaths
-}
-
-export function getPathsFromPlaneArtifact(planeArtifact: PlaneArtifact) {
-  const nodePaths: PathToNode[] = []
-  for (const pathId of planeArtifact.pathIds) {
-    const path = engineCommandManager.artifactGraph.get(pathId)
-    if (!path) continue
-    if ('codeRef' in path && path.codeRef) {
-      // TODO should figure out why upstream the path is bad
-      const isNodePathBad = path.codeRef.pathToNode.length < 2
-      nodePaths.push(
-        isNodePathBad
-          ? getNodePathFromSourceRange(kclManager.ast, path.codeRef.range)
-          : path.codeRef.pathToNode
-      )
-    }
-  }
-  return onlyConsecutivePaths(nodePaths, nodePaths[0])
-}
-
-export function getPathsFromArtifact({
-  sketchPathToNode,
-  artifact,
-}: {
-  sketchPathToNode: PathToNode
-  artifact?: Artifact
-}): PathToNode[] | Error {
-  const plane = getPlaneFromArtifact(
-    artifact,
-    engineCommandManager.artifactGraph
-  )
-  if (err(plane)) return plane
-  const paths = getArtifactsOfTypes(
-    { keys: plane.pathIds, types: ['path'] },
-    engineCommandManager.artifactGraph
-  )
-  let nodePaths = [...paths.values()]
-    .map((path) => path.codeRef.pathToNode)
-    .sort((a, b) => Number(a[1][0]) - Number(b[1][0]))
-  return onlyConsecutivePaths(nodePaths, sketchPathToNode)
-}
-
-function isNodeSafe(node: Expr): boolean {
-  if (node.type === 'Literal' || node.type === 'MemberExpression') {
-    return true
-  }
-  if (node.type === 'BinaryExpression') {
-    return isNodeSafe(node.left) && isNodeSafe(node.right)
-  }
-  return false
-}

src/lang/std/engineConnection.ts

@@ -1,4 +1,4 @@
-import { defaultSourceRange, SourceRange, Program } from 'lang/wasm'
+import { defaultSourceRange, SourceRange } from 'lang/wasm'
 import { VITE_KC_API_WS_MODELING_URL, VITE_KC_DEV_TOKEN } from 'env'
 import { Models } from '@kittycad/lib'
 import { exportSave } from 'lib/exportSave'
@@ -1399,6 +1399,7 @@ export class EngineCommandManager extends EventTarget {
   }
 
   private makeDefaultPlanes: () => Promise<DefaultPlanes> | null = () => null
+  private modifyGrid: (hidden: boolean) => Promise<void> | null = () => null
 
   private onEngineConnectionOpened = () => {}
   private onEngineConnectionClosed = () => {}
@@ -1431,6 +1432,7 @@ export class EngineCommandManager extends EventTarget {
     height,
     token,
     makeDefaultPlanes,
+    modifyGrid,
     settings = {
       pool: null,
       theme: Themes.Dark,
@@ -1450,12 +1452,14 @@ export class EngineCommandManager extends EventTarget {
     height: number
     token?: string
     makeDefaultPlanes: () => Promise<DefaultPlanes>
+    modifyGrid: (hidden: boolean) => Promise<void>
     settings?: SettingsViaQueryString
   }) {
     if (settings) {
       this.settings = settings
     }
     this.makeDefaultPlanes = makeDefaultPlanes
+    this.modifyGrid = modifyGrid
     if (width === 0 || height === 0) {
       return
     }
@@ -1535,15 +1539,21 @@ export class EngineCommandManager extends EventTarget {
           type: 'default_camera_get_settings',
         },
       })
-      await this.initPlanes()
-      setIsStreamReady(true)
+      // We want modify the grid first because we don't want it to flash.
+      // Ideally these would already be default hidden in engine (TODO do
+      // that) https://github.com/KittyCAD/engine/issues/2282
+      // eslint-disable-next-line @typescript-eslint/no-floating-promises
+      this.modifyGrid(!this.settings.showScaleGrid)?.then(async () => {
+        await this.initPlanes()
+        setIsStreamReady(true)
 
-      // Other parts of the application should use this to react on scene ready.
-      this.dispatchEvent(
-        new CustomEvent(EngineCommandManagerEvents.SceneReady, {
-          detail: this.engineConnection,
-        })
-      )
+        // Other parts of the application should use this to react on scene ready.
+        this.dispatchEvent(
+          new CustomEvent(EngineCommandManagerEvents.SceneReady, {
+            detail: this.engineConnection,
+          })
+        )
+      })
     }
 
     this.engineConnection.addEventListener(
@@ -2099,23 +2109,30 @@ export class EngineCommandManager extends EventTarget {
    * When an execution takes place we want to wait until we've got replies for all of the commands
    * When this is done when we build the artifact map synchronously.
    */
-  waitForAllCommands() {
-    return Promise.all(
-      Object.values(this.pendingCommands).map((a) => a.promise)
-    )
-  }
-  updateArtifactGraph(ast: Program) {
-    this.artifactGraph = createArtifactGraph({
-      orderedCommands: this.orderedCommands,
-      responseMap: this.responseMap,
-      ast,
+  async waitForAllCommands(useFakeExecutor = false) {
+    await Promise.all(Object.values(this.pendingCommands).map((a) => a.promise))
+    setTimeout(() => {
+      // the ast is wrong without this one tick timeout.
+      // an example is `Solids should be select and deletable` e2e test will fail
+      // because the out of date ast messes with selections
+      // TODO: race condition
+      if (!this?.kclManager) return
+      this.artifactGraph = createArtifactGraph({
+        orderedCommands: this.orderedCommands,
+        responseMap: this.responseMap,
+        ast: this.kclManager.ast,
+      })
+      if (useFakeExecutor) {
+        // mock executions don't produce an artifactGraph, so this will always be empty
+        // skipping the below logic to wait for the next real execution
+        return
+      }
+      if (this.artifactGraph.size) {
+        this.deferredArtifactEmptied(null)
+      } else {
+        this.deferredArtifactPopulated(null)
+      }
     })
-    // TODO check if these still need to be deferred once e2e tests are working again.
-    if (this.artifactGraph.size) {
-      this.deferredArtifactEmptied(null)
-    } else {
-      this.deferredArtifactPopulated(null)
-    }
   }
 
   /**
@@ -2195,6 +2212,15 @@ export class EngineCommandManager extends EventTarget {
     }).catch(reportRejection)
   }
 
+  /**
+   * Set the visibility of the scale grid in the engine scene.
+   * @param visible - whether to show or hide the scale grid
+   */
+  setScaleGridVisibility(visible: boolean) {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.modifyGrid(!visible)
+  }
+
   // Some "objects" have the same source range, such as sketch_mode_start and start_path.
   // So when passing a range, we need to also specify the command type
   mapRangeToObjectId(
@@ -2202,11 +2228,7 @@ export class EngineCommandManager extends EventTarget {
     commandTypeToTarget: string
   ): string | undefined {
     for (const [artifactId, artifact] of this.artifactGraph) {
-      if (
-        'codeRef' in artifact &&
-        artifact.codeRef &&
-        isOverlap(range, artifact.codeRef.range)
-      ) {
+      if ('codeRef' in artifact && isOverlap(range, artifact.codeRef.range)) {
         if (commandTypeToTarget === artifact.type) return artifactId
       }
     }

src/lang/std/sketch.ts

@@ -297,20 +297,14 @@ export const lineTo: SketchLineHelper = {
   add: ({ node, pathToNode, segmentInput, replaceExistingCallback }) => {
     if (segmentInput.type !== 'straight-segment') return STRAIGHT_SEGMENT_ERR
     const to = segmentInput.to
-    const _node = structuredClone(node)
+    const _node = { ...node }
     const nodeMeta = getNodeFromPath<PipeExpression>(
       _node,
       pathToNode,
       'PipeExpression'
     )
     if (err(nodeMeta)) return nodeMeta
-    const varDec = getNodeFromPath<VariableDeclaration>(
-      _node,
-      pathToNode,
-      'VariableDeclaration'
-    )
-    if (err(varDec)) return varDec
-    const dec = varDec.node.declaration
+    const { node: pipe } = nodeMeta
 
     const newVals: [Expr, Expr] = [
       createLiteral(roundOff(to[0], 2)),
@@ -339,20 +333,14 @@ export const lineTo: SketchLineHelper = {
       ])
       if (err(result)) return result
       const { callExp, valueUsedInTransform } = result
-      if (dec.init.type === 'PipeExpression') {
-        dec.init.body[callIndex] = callExp
-      } else {
-        dec.init = callExp
-      }
+      pipe.body[callIndex] = callExp
       return {
         modifiedAst: _node,
         pathToNode,
         valueUsedInTransform: valueUsedInTransform,
       }
-    } else if (dec.init.type === 'PipeExpression') {
-      dec.init.body = [...dec.init.body, newLine]
     } else {
-      dec.init = createPipeExpression([dec.init, newLine])
+      pipe.body = [...pipe.body, newLine]
     }
     return {
       modifiedAst: _node,
@@ -675,11 +663,11 @@ export const xLine: SketchLineHelper = {
   add: ({ node, pathToNode, segmentInput, replaceExistingCallback }) => {
     if (segmentInput.type !== 'straight-segment') return STRAIGHT_SEGMENT_ERR
     const { from, to } = segmentInput
-    const _node = structuredClone(node)
+    const _node = { ...node }
     const getNode = getNodeFromPathCurry(_node, pathToNode)
-    const varDec = getNode<VariableDeclaration>('VariableDeclaration')
-    if (err(varDec)) return varDec
-    const dec = varDec.node.declaration
+    const _node1 = getNode<PipeExpression>('PipeExpression')
+    if (err(_node1)) return _node1
+    const { node: pipe } = _node1
 
     const newVal = createLiteral(roundOff(to[0] - from[0], 2))
 
@@ -694,11 +682,7 @@ export const xLine: SketchLineHelper = {
       ])
       if (err(result)) return result
       const { callExp, valueUsedInTransform } = result
-      if (dec.init.type === 'PipeExpression') {
-        dec.init.body[callIndex] = callExp
-      } else {
-        dec.init = callExp
-      }
+      pipe.body[callIndex] = callExp
       return {
         modifiedAst: _node,
         pathToNode,
@@ -710,11 +694,7 @@ export const xLine: SketchLineHelper = {
       newVal,
       createPipeSubstitution(),
     ])
-    if (dec.init.type === 'PipeExpression') {
-      dec.init.body = [...dec.init.body, newLine]
-    } else {
-      dec.init = createPipeExpression([dec.init, newLine])
-    }
+    pipe.body = [...pipe.body, newLine]
     return { modifiedAst: _node, pathToNode }
   },
   updateArgs: ({ node, pathToNode, input }) => {
@@ -751,11 +731,11 @@ export const yLine: SketchLineHelper = {
   add: ({ node, pathToNode, segmentInput, replaceExistingCallback }) => {
     if (segmentInput.type !== 'straight-segment') return STRAIGHT_SEGMENT_ERR
     const { from, to } = segmentInput
-    const _node = structuredClone(node)
+    const _node = { ...node }
     const getNode = getNodeFromPathCurry(_node, pathToNode)
-    const varDec = getNode<VariableDeclaration>('VariableDeclaration')
-    if (err(varDec)) return varDec
-    const dec = varDec.node.declaration
+    const _node1 = getNode<PipeExpression>('PipeExpression')
+    if (err(_node1)) return _node1
+    const { node: pipe } = _node1
     const newVal = createLiteral(roundOff(to[1] - from[1], 2))
     if (replaceExistingCallback) {
       const { index: callIndex } = splitPathAtPipeExpression(pathToNode)
@@ -768,11 +748,7 @@ export const yLine: SketchLineHelper = {
       ])
       if (err(result)) return result
       const { callExp, valueUsedInTransform } = result
-      if (dec.init.type === 'PipeExpression') {
-        dec.init.body[callIndex] = callExp
-      } else {
-        dec.init = callExp
-      }
+      pipe.body[callIndex] = callExp
       return {
         modifiedAst: _node,
         pathToNode,
@@ -784,11 +760,7 @@ export const yLine: SketchLineHelper = {
       newVal,
       createPipeSubstitution(),
     ])
-    if (dec.init.type === 'PipeExpression') {
-      dec.init.body = [...dec.init.body, newLine]
-    } else {
-      dec.init = createPipeExpression([dec.init, newLine])
-    }
+    pipe.body = [...pipe.body, newLine]
     return { modifiedAst: _node, pathToNode }
   },
   updateArgs: ({ node, pathToNode, input }) => {
@@ -2173,6 +2145,8 @@ function addTagToChamfer(
   if (err(variableDec)) return variableDec
   const isPipeExpression = pipeExpr.node.type === 'PipeExpression'
 
+  console.log('pipeExpr', pipeExpr, variableDec)
+  // const callExpr = isPipeExpression ? pipeExpr.node.body[pipeIndex] : variableDec.node.init
   const callExpr = isPipeExpression
     ? pipeExpr.node.body[pipeIndex]
     : variableDec.node.init
@@ -2253,6 +2227,7 @@ function addTagToChamfer(
   if (isPipeExpression) {
     pipeExpr.node.body.splice(pipeIndex, 0, newExpressionToInsert)
   } else {
+    console.log('yo', createPipeExpression([newExpressionToInsert, callExpr]))
     callExpr.arguments[1] = createPipeSubstitution()
     variableDec.node.init = createPipeExpression([
       newExpressionToInsert,

src/lang/util.ts

@@ -9,47 +9,20 @@ import {
 import { ArtifactGraph, filterArtifacts } from 'lang/std/artifactGraph'
 import { isOverlap } from 'lib/utils'
 
-/**
- * Updates pathToNode body indices to account for the insertion of an expression
- * PathToNode expression is after the insertion index, that the body index is incremented
- * Negative insertion index means no insertion
- */
-export function updatePathToNodePostExprInjection(
-  pathToNode: PathToNode,
-  exprInsertIndex: number
+export function updatePathToNodeFromMap(
+  oldPath: PathToNode,
+  pathToNodeMap: { [key: number]: PathToNode }
 ): PathToNode {
-  if (exprInsertIndex < 0) return pathToNode
-  const bodyIndex = Number(pathToNode[1][0])
-  if (bodyIndex < exprInsertIndex) return pathToNode
-  const clone = structuredClone(pathToNode)
-  clone[1][0] = bodyIndex + 1
-  return clone
-}
-
-export function updateSketchDetailsNodePaths({
-  sketchEntryNodePath,
-  sketchNodePaths,
-  planeNodePath,
-  exprInsertIndex,
-}: {
-  sketchEntryNodePath: PathToNode
-  sketchNodePaths: Array<PathToNode>
-  planeNodePath: PathToNode
-  exprInsertIndex: number
-}) {
-  return {
-    updatedSketchEntryNodePath: updatePathToNodePostExprInjection(
-      sketchEntryNodePath,
-      exprInsertIndex
-    ),
-    updatedSketchNodePaths: sketchNodePaths.map((path) =>
-      updatePathToNodePostExprInjection(path, exprInsertIndex)
-    ),
-    updatedPlaneNodePath: updatePathToNodePostExprInjection(
-      planeNodePath,
-      exprInsertIndex
-    ),
-  }
+  const updatedPathToNode = structuredClone(oldPath)
+  let max = 0
+  Object.values(pathToNodeMap).forEach((path) => {
+    const index = Number(path[1][0])
+    if (index > max) {
+      max = index
+    }
+  })
+  updatedPathToNode[1][0] = max
+  return updatedPathToNode
 }
 
 export function isCursorInSketchCommandRange(
@@ -58,7 +31,7 @@ export function isCursorInSketchCommandRange(
 ): string | false {
   const overlappingEntries = filterArtifacts(
     {
-      types: ['segment', 'path', 'plane'],
+      types: ['segment', 'path'],
       predicate: (artifact) => {
         return selectionRanges.graphSelections.some(
           (selection) =>