bump and release kcl-lib

.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
 
@@ -359,17 +362,6 @@ jobs:
       - name: List artifacts
         run: "ls -R out"
 
-      - name: Set more complete nightly release notes
-        if: ${{ env.IS_NIGHTLY == 'true' }}
-        run: |
-          # Note: preferred going this way instead of a full clone in the checkout step,
-          # see https://github.com/actions/checkout/issues/1471
-          git fetch --prune --unshallow --tags
-          export TAG="nightly-${VERSION}"
-          export PREVIOUS_TAG=$(git describe --tags --match="nightly-v[0-9]*" --abbrev=0)
-          export NOTES=$(./scripts/get-nightly-changelog.sh)
-          yarn files:set-notes
-
       - name: Authenticate to Google Cloud
         if: ${{ env.IS_NIGHTLY == 'true' }}
         uses: 'google-github-actions/auth@v2.1.7'
@@ -390,18 +382,3 @@ jobs:
           glob: '*'
           parent: false
           destination: 'dl.kittycad.io/releases/modeling-app/nightly'
-
-      - name: Invalidate bucket cache on latest*.yml and last_download.json files
-        if: ${{ env.IS_NIGHTLY == 'true' }}
-        run: yarn files:invalidate-bucket:nightly
-
-      - name: Tag nightly commit
-        if: ${{ env.IS_NIGHTLY == 'true' }}
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const { VERSION } = process.env          
-            const { owner, repo } = context.repo
-            const { sha } = context
-            const ref = `refs/tags/nightly-${VERSION}`
-            github.rest.git.createRef({ owner, repo, sha, ref })

.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

.github/workflows/publish-apps-release.yml

@@ -126,7 +126,11 @@ jobs:
           destination: 'dl.kittycad.io/releases/modeling-app'
 
       - name: Invalidate bucket cache on latest*.yml and last_download.json files
-        run: yarn files:invalidate-bucket
+        run: |
+          gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="/releases/modeling-app/last_download.json" --async
+          gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="/releases/modeling-app/latest-linux-arm64.yml" --async
+          gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="/releases/modeling-app/latest-mac.yml" --async
+          gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="/releases/modeling-app/latest.yml" --async
 
       - name: Upload release files to Github
         if: ${{ github.event_name == 'release' }}

.gitignore

@@ -61,7 +61,6 @@ Mac_App_Distribution.provisionprofile
 *.tsbuildinfo
 src/wasm-lib/pkg
 
-.eslintcache
 venv
 .vite/
 

.nvmrc

@@ -1 +1 @@
-v22.12.0
+v21.7.3

INSTALL.md

@@ -1,43 +0,0 @@
-# Setting Up Zoo Modeling App
-
-Compared to other CAD software, getting Zoo Modeling App up and running is quick and straightforward across platforms. It's about 100MB to download and is quick to install.
-
-## Windows
-
-1. Download the [Zoo Modeling App installer](https://zoo.dev/modeling-app/download) for Windows and for your processor type.
-
-2. Once downloaded, run the installer `Zoo Modeling App-{version}-{arch}-win.exe` which should take a few seconds.
-
-3. The installation happens at `C:\Program Files\Zoo Modeling App`. A shortcut in the start menu is also created so you can run the app easily by clicking on it.
-
-## macOS
-
-1. Download the [Zoo Modeling App installer](https://zoo.dev/modeling-app/download) for macOS and for your processor type.
-
-2. Once downloaded, open the disk image `Zoo Modeling App-{version}-{arch}-mac.dmg` and drag the applications to your `Applications` directory.
-
-3. You can then open your `Applications` directory and double-click on `Zoo Modeling App` to open.
-
-
-## Linux 
-
-1. Download the [Zoo Modeling App installer](https://zoo.dev/modeling-app/download) for Linux and for your processor type.
-
-2. Install the dependencies needed to run the [AppImage format](https://appimage.org/).
-    -  On Ubuntu, install the FUSE library with these commands in a terminal.
-       ```bash
-       sudo apt update
-       sudo apt install libfuse2
-       ```
-    - Optionally, follow [these steps](https://github.com/probonopd/go-appimage/blob/master/src/appimaged/README.md#initial-setup) to install `appimaged`. It is a daemon that makes interacting with AppImage files more seamless. 
-    - Once installed, copy the downloaded `Zoo Modeling App-{version}-{arch}-linux.AppImage` to the directory of your choice, for instance `~/Applications`.
-
-   - `appimaged` should automatically find it and make it executable. If not, run:
-     ```bash
-     chmod a+x ~/Applications/Zoo\ Modeling\ App-{version}-{arch}-linux.AppImage
-     ```
-
-3. You can double-click on the AppImage to run it, or in a terminal with this command:
-   ```bash
-    ~/Applications/Zoo\ Modeling\ App-{version}-{arch}-linux.AppImage
-   ```

README.md

@@ -99,7 +99,7 @@ yarn tron:start
 
 This will start the application and hot-reload on changes.
 
-Devtools can be opened with the usual Cmd-Opt-I (Mac) or Ctrl-Shift-I (Linux and Windows).
+Devtools can be opened with the usual Cmd/Ctrl-Shift-I.
 
 To build, run `yarn tron:package`.
 

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/editor-tests.spec.ts

@@ -458,8 +458,8 @@ test.describe('Editor tests', () => {
 
     /* add the following code to the editor ($ error is not a valid line)
       $ error
-      topAng = 30
-      bottomAng = 25
+      const topAng = 30
+      const bottomAng = 25
      */
     await u.codeLocator.click()
     await page.keyboard.type('$ error')
@@ -474,14 +474,12 @@ test.describe('Editor tests', () => {
     await page.keyboard.type('bottomAng = 25')
     await page.keyboard.press('Enter')
 
-    // error in gutter
+    // error in guter
     await expect(page.locator('.cm-lint-marker-error')).toBeVisible()
 
     // error text on hover
     await page.hover('.cm-lint-marker-error')
-    await expect(
-      page.getByText('Tag names must not be empty').first()
-    ).toBeVisible()
+    await expect(page.getByText('Unexpected token: $').first()).toBeVisible()
 
     // select the line that's causing the error and delete it
     await page.getByText('$ error').click()
@@ -520,10 +518,7 @@ test.describe('Editor tests', () => {
     await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
   })
 
-  // TODO currently multiple source ranges are not supported
-  test.skip('error with 2 source ranges gets 2 diagnostics', async ({
-    page,
-  }) => {
+  test('error with 2 source ranges gets 2 diagnostics', async ({ page }) => {
     const u = await getUtils(page)
     await page.addInitScript(async () => {
       localStorage.setItem(

e2e/playwright/fixtures/toolbarFixture.ts

@@ -6,8 +6,6 @@ export class ToolbarFixture {
   public page: Page
 
   extrudeButton!: Locator
-  loftButton!: Locator
-  shellButton!: Locator
   offsetPlaneButton!: Locator
   startSketchBtn!: Locator
   lineBtn!: Locator
@@ -28,8 +26,6 @@ export class ToolbarFixture {
   reConstruct = (page: Page) => {
     this.page = page
     this.extrudeButton = page.getByTestId('extrude')
-    this.loftButton = page.getByTestId('loft')
-    this.shellButton = page.getByTestId('shell')
     this.offsetPlaneButton = page.getByTestId('plane-offset')
     this.startSketchBtn = page.getByTestId('sketch')
     this.lineBtn = page.getByTestId('line')

e2e/playwright/point-click.spec.ts

@@ -677,259 +677,3 @@ test(`Offset plane point-and-click`, async ({
     await scene.expectPixelColor([74, 74, 74], testPoint, 15)
   })
 })
-
-const loftPointAndClickCases = [
-  { shouldPreselect: true },
-  { shouldPreselect: false },
-]
-loftPointAndClickCases.forEach(({ shouldPreselect }) => {
-  test(`Loft point-and-click (preselected sketches: ${shouldPreselect})`, async ({
-    app,
-    page,
-    scene,
-    editor,
-    toolbar,
-    cmdBar,
-  }) => {
-    const initialCode = `sketch001 = startSketchOn('XZ')
-    |> circle({ center = [0, 0], radius = 30 }, %)
-    plane001 = offsetPlane('XZ', 50)
-    sketch002 = startSketchOn(plane001)
-    |> circle({ center = [0, 0], radius = 20 }, %)
-`
-    await app.initialise(initialCode)
-
-    // One dumb hardcoded screen pixel value
-    const testPoint = { x: 575, y: 200 }
-    const [clickOnSketch1] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
-    const [clickOnSketch2] = scene.makeMouseHelpers(
-      testPoint.x,
-      testPoint.y + 80
-    )
-    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)
-    })
-
-    async function selectSketches() {
-      await clickOnSketch1()
-      await page.keyboard.down('Shift')
-      await clickOnSketch2()
-      await app.page.waitForTimeout(500)
-      await page.keyboard.up('Shift')
-    }
-
-    if (!shouldPreselect) {
-      await test.step(`Go through the command bar flow without preselected sketches`, async () => {
-        await toolbar.loftButton.click()
-        await cmdBar.expectState({
-          stage: 'arguments',
-          currentArgKey: 'selection',
-          currentArgValue: '',
-          headerArguments: { Selection: '' },
-          highlightedHeaderArg: 'selection',
-          commandName: 'Loft',
-        })
-        await selectSketches()
-        await cmdBar.progressCmdBar()
-        await cmdBar.expectState({
-          stage: 'review',
-          headerArguments: { Selection: '2 faces' },
-          commandName: 'Loft',
-        })
-        await cmdBar.progressCmdBar()
-      })
-    } else {
-      await test.step(`Preselect the two sketches`, async () => {
-        await selectSketches()
-      })
-
-      await test.step(`Go through the command bar flow with preselected sketches`, async () => {
-        await toolbar.loftButton.click()
-        await cmdBar.progressCmdBar()
-        await cmdBar.expectState({
-          stage: 'review',
-          headerArguments: { Selection: '2 faces' },
-          commandName: 'Loft',
-        })
-        await cmdBar.progressCmdBar()
-      })
-    }
-
-    await test.step(`Confirm code is added to the editor, scene has changed`, async () => {
-      await editor.expectEditor.toContain(loftDeclaration)
-      await editor.expectState({
-        diagnostics: [],
-        activeLines: [loftDeclaration],
-        highlightedCode: '',
-      })
-      await scene.expectPixelColor([89, 89, 89], testPoint, 15)
-    })
-  })
-})
-
-const shellPointAndClickCapCases = [
-  { shouldPreselect: true },
-  { shouldPreselect: false },
-]
-shellPointAndClickCapCases.forEach(({ shouldPreselect }) => {
-  test(`Shell point-and-click cap (preselected sketches: ${shouldPreselect})`, async ({
-    app,
-    scene,
-    editor,
-    toolbar,
-    cmdBar,
-  }) => {
-    const initialCode = `sketch001 = startSketchOn('XZ')
-    |> circle({ center = [0, 0], radius = 30 }, %)
-    extrude001 = extrude(30, sketch001)
-    `
-    await app.initialise(initialCode)
-
-    // One dumb hardcoded screen pixel value
-    const testPoint = { x: 575, y: 200 }
-    const [clickOnCap] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
-    const shellDeclaration =
-      "shell001 = shell({ faces = ['end'], thickness = 5 }, extrude001)"
-
-    await test.step(`Look for the grey of the shape`, async () => {
-      await scene.expectPixelColor([127, 127, 127], testPoint, 15)
-    })
-
-    if (!shouldPreselect) {
-      await test.step(`Go through the command bar flow without preselected faces`, async () => {
-        await toolbar.shellButton.click()
-        await cmdBar.expectState({
-          stage: 'arguments',
-          currentArgKey: 'selection',
-          currentArgValue: '',
-          headerArguments: {
-            Selection: '',
-            Thickness: '',
-          },
-          highlightedHeaderArg: 'selection',
-          commandName: 'Shell',
-        })
-        await clickOnCap()
-        await app.page.waitForTimeout(500)
-        await cmdBar.progressCmdBar()
-        await cmdBar.progressCmdBar()
-        await cmdBar.expectState({
-          stage: 'review',
-          headerArguments: {
-            Selection: '1 cap',
-            Thickness: '5',
-          },
-          commandName: 'Shell',
-        })
-        await cmdBar.progressCmdBar()
-      })
-    } 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 () => {
-        await toolbar.shellButton.click()
-        await cmdBar.progressCmdBar()
-        await cmdBar.progressCmdBar()
-        await cmdBar.expectState({
-          stage: 'review',
-          headerArguments: {
-            Selection: '1 cap',
-            Thickness: '5',
-          },
-          commandName: 'Shell',
-        })
-        await cmdBar.progressCmdBar()
-      })
-    }
-
-    await test.step(`Confirm code is added to the editor, scene has changed`, async () => {
-      await editor.expectEditor.toContain(shellDeclaration)
-      await editor.expectState({
-        diagnostics: [],
-        activeLines: [shellDeclaration],
-        highlightedCode: '',
-      })
-      await scene.expectPixelColor([146, 146, 146], testPoint, 15)
-    })
-  })
-})
-
-test('Shell point-and-click wall', async ({
-  app,
-  page,
-  scene,
-  editor,
-  toolbar,
-  cmdBar,
-}) => {
-  const initialCode = `sketch001 = startSketchOn('XY')
-  |> startProfileAt([-20, 20], %)
-  |> xLine(40, %)
-  |> yLine(-60, %)
-  |> xLine(-40, %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-extrude001 = extrude(40, sketch001)
-  `
-  await app.initialise(initialCode)
-
-  // One dumb hardcoded screen pixel value
-  const testPoint = { x: 580, y: 180 }
-  const [clickOnCap] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
-  const [clickOnWall] = scene.makeMouseHelpers(testPoint.x, testPoint.y + 70)
-  const mutatedCode = 'xLine(-40, %, $seg01)'
-  const shellDeclaration =
-    "shell001 = shell({  faces = ['end', seg01],  thickness = 5}, extrude001)"
-  const formattedOutLastLine = '}, extrude001)'
-
-  await test.step(`Look for the grey of the shape`, async () => {
-    await scene.expectPixelColor([99, 99, 99], testPoint, 15)
-  })
-
-  await test.step(`Go through the command bar flow, selecting a wall and keeping default thickness`, async () => {
-    await toolbar.shellButton.click()
-    await cmdBar.expectState({
-      stage: 'arguments',
-      currentArgKey: 'selection',
-      currentArgValue: '',
-      headerArguments: {
-        Selection: '',
-        Thickness: '',
-      },
-      highlightedHeaderArg: 'selection',
-      commandName: 'Shell',
-    })
-    await clickOnCap()
-    await page.keyboard.down('Shift')
-    await clickOnWall()
-    await app.page.waitForTimeout(500)
-    await page.keyboard.up('Shift')
-    await cmdBar.progressCmdBar()
-    await cmdBar.progressCmdBar()
-    await cmdBar.expectState({
-      stage: 'review',
-      headerArguments: {
-        Selection: '1 cap, 1 face',
-        Thickness: '5',
-      },
-      commandName: 'Shell',
-    })
-    await cmdBar.progressCmdBar()
-  })
-
-  await test.step(`Confirm code is added to the editor, scene has changed`, async () => {
-    await editor.expectEditor.toContain(mutatedCode)
-    await editor.expectEditor.toContain(shellDeclaration)
-    await editor.expectState({
-      diagnostics: [],
-      activeLines: [formattedOutLastLine],
-      highlightedCode: '',
-    })
-    await scene.expectPixelColor([49, 49, 49], testPoint, 15)
-  })
-})

e2e/playwright/projects.spec.ts

@@ -136,335 +136,6 @@ test(
   }
 )
 
-test(
-  'open a file in a project works and renders, open another file in different project with errors, it should clear the scene',
-  { tag: '@electron' },
-  async ({ browserName }, testInfo) => {
-    const { electronApp, page } = await setupElectron({
-      testInfo,
-      folderSetupFn: async (dir) => {
-        const bracketDir = join(dir, 'bracket')
-        await fsp.mkdir(bracketDir, { recursive: true })
-        await fsp.copyFile(
-          executorInputPath('focusrite_scarlett_mounting_braket.kcl'),
-          join(bracketDir, 'main.kcl')
-        )
-        const errorDir = join(dir, 'broken-code')
-        await fsp.mkdir(errorDir, { recursive: true })
-        await fsp.copyFile(
-          executorInputPath('broken-code-test.kcl'),
-          join(errorDir, 'main.kcl')
-        )
-      },
-    })
-
-    await page.setViewportSize({ width: 1200, height: 500 })
-    const u = await getUtils(page)
-
-    page.on('console', console.log)
-
-    const pointOnModel = { x: 630, y: 280 }
-
-    await test.step('Opening the bracket project should load the stream', async () => {
-      // expect to see the text bracket
-      await expect(page.getByText('bracket')).toBeVisible()
-
-      await page.getByText('bracket').click()
-
-      await expect(page.getByTestId('loading')).toBeAttached()
-      await expect(page.getByTestId('loading')).not.toBeAttached({
-        timeout: 20_000,
-      })
-
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).toBeEnabled({
-        timeout: 20_000,
-      })
-
-      // gray at this pixel means the stream has loaded in the most
-      // user way we can verify it (pixel color)
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [85, 85, 85]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-
-    await test.step('Clicking the logo takes us back to the projects page / home', async () => {
-      await page.getByTestId('app-logo').click()
-
-      await expect(page.getByRole('link', { name: 'bracket' })).toBeVisible()
-      await expect(page.getByText('broken-code')).toBeVisible()
-      await expect(page.getByText('bracket')).toBeVisible()
-      await expect(page.getByText('New Project')).toBeVisible()
-    })
-    await test.step('opening broken code project should clear the scene and show the error', async () => {
-      // Go back home.
-      await expect(page.getByText('broken-code')).toBeVisible()
-
-      await page.getByText('broken-code').click()
-
-      // error in guter
-      await expect(page.locator('.cm-lint-marker-error')).toBeVisible()
-
-      // error text on hover
-      await page.hover('.cm-lint-marker-error')
-      const crypticErrorText = `Expected a tag declarator`
-      await expect(page.getByText(crypticErrorText).first()).toBeVisible()
-
-      // black pixel means the scene has been cleared.
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [30, 30, 30]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-
-    await electronApp.close()
-  }
-)
-
-test(
-  'open a file in a project works and renders, open another file in different project that is empty, it should clear the scene',
-  { tag: '@electron' },
-  async ({ browserName }, testInfo) => {
-    const { electronApp, page } = await setupElectron({
-      testInfo,
-      folderSetupFn: async (dir) => {
-        const bracketDir = join(dir, 'bracket')
-        await fsp.mkdir(bracketDir, { recursive: true })
-        await fsp.copyFile(
-          executorInputPath('focusrite_scarlett_mounting_braket.kcl'),
-          join(bracketDir, 'main.kcl')
-        )
-        const emptyDir = join(dir, 'empty')
-        await fsp.mkdir(emptyDir, { recursive: true })
-        await fsp.writeFile(join(emptyDir, 'main.kcl'), '')
-      },
-    })
-
-    await page.setViewportSize({ width: 1200, height: 500 })
-    const u = await getUtils(page)
-
-    page.on('console', console.log)
-
-    const pointOnModel = { x: 630, y: 280 }
-
-    await test.step('Opening the bracket project should load the stream', async () => {
-      // expect to see the text bracket
-      await expect(page.getByText('bracket')).toBeVisible()
-
-      await page.getByText('bracket').click()
-
-      await expect(page.getByTestId('loading')).toBeAttached()
-      await expect(page.getByTestId('loading')).not.toBeAttached({
-        timeout: 20_000,
-      })
-
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).toBeEnabled({
-        timeout: 20_000,
-      })
-
-      // gray at this pixel means the stream has loaded in the most
-      // user way we can verify it (pixel color)
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [85, 85, 85]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-
-    await test.step('Clicking the logo takes us back to the projects page / home', async () => {
-      await page.getByTestId('app-logo').click()
-
-      await expect(page.getByRole('link', { name: 'bracket' })).toBeVisible()
-      await expect(page.getByText('empty')).toBeVisible()
-      await expect(page.getByText('bracket')).toBeVisible()
-      await expect(page.getByText('New Project')).toBeVisible()
-    })
-    await test.step('opening empty code project should clear the scene', async () => {
-      // Go back home.
-      await expect(page.getByText('empty')).toBeVisible()
-
-      await page.getByText('empty').click()
-
-      // Ensure the code is empty.
-      await expect(u.codeLocator).toContainText('')
-      expect(u.codeLocator.innerHTML.length).toBeLessThan(2)
-
-      // planes colors means the scene has been cleared.
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [92, 53, 53]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-
-    await electronApp.close()
-  }
-)
-
-test(
-  'open a file in a project works and renders, open empty file, it should clear the scene',
-  { tag: '@electron' },
-  async ({ browserName }, testInfo) => {
-    const { electronApp, page } = await setupElectron({
-      testInfo,
-      folderSetupFn: async (dir) => {
-        const bracketDir = join(dir, 'bracket')
-        await fsp.mkdir(bracketDir, { recursive: true })
-        await fsp.copyFile(
-          executorInputPath('focusrite_scarlett_mounting_braket.kcl'),
-          join(bracketDir, 'main.kcl')
-        )
-
-        await fsp.writeFile(join(bracketDir, 'empty.kcl'), '')
-      },
-    })
-
-    await page.setViewportSize({ width: 1200, height: 500 })
-    const u = await getUtils(page)
-
-    page.on('console', console.log)
-
-    const pointOnModel = { x: 630, y: 280 }
-
-    await test.step('Opening the bracket project should load the stream', async () => {
-      // expect to see the text bracket
-      await expect(page.getByText('bracket')).toBeVisible()
-
-      await page.getByText('bracket').click()
-
-      await expect(page.getByTestId('loading')).toBeAttached()
-      await expect(page.getByTestId('loading')).not.toBeAttached({
-        timeout: 20_000,
-      })
-
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).toBeEnabled({
-        timeout: 20_000,
-      })
-
-      // gray at this pixel means the stream has loaded in the most
-      // user way we can verify it (pixel color)
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [85, 85, 85]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-    await test.step('creating a empty file should clear the scene', async () => {
-      // open the file pane.
-      await page.getByTestId('files-pane-button').click()
-
-      // OPen the other file.
-      const file = page.getByRole('button', { name: 'empty.kcl' })
-      await expect(file).toBeVisible()
-
-      await file.click()
-
-      // planes colors means the scene has been cleared.
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [92, 53, 53]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-
-      // Ensure the code is empty.
-      await expect(u.codeLocator).toContainText('')
-      expect(u.codeLocator.innerHTML.length).toBeLessThan(2)
-    })
-
-    await electronApp.close()
-  }
-)
-
-test(
-  'open a file in a project works and renders, open another file in the same project with errors, it should clear the scene',
-  { tag: '@electron' },
-  async ({ browserName }, testInfo) => {
-    const { electronApp, page } = await setupElectron({
-      testInfo,
-      folderSetupFn: async (dir) => {
-        const bracketDir = join(dir, 'bracket')
-        await fsp.mkdir(bracketDir, { recursive: true })
-        await fsp.copyFile(
-          executorInputPath('focusrite_scarlett_mounting_braket.kcl'),
-          join(bracketDir, 'main.kcl')
-        )
-        await fsp.copyFile(
-          executorInputPath('broken-code-test.kcl'),
-          join(bracketDir, 'broken-code-test.kcl')
-        )
-      },
-    })
-
-    await page.setViewportSize({ width: 1200, height: 500 })
-    const u = await getUtils(page)
-
-    page.on('console', console.log)
-
-    const pointOnModel = { x: 630, y: 280 }
-
-    await test.step('Opening the bracket project should load the stream', async () => {
-      // expect to see the text bracket
-      await expect(page.getByText('bracket')).toBeVisible()
-
-      await page.getByText('bracket').click()
-
-      await expect(page.getByTestId('loading')).toBeAttached()
-      await expect(page.getByTestId('loading')).not.toBeAttached({
-        timeout: 20_000,
-      })
-
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).toBeEnabled({
-        timeout: 20_000,
-      })
-
-      // gray at this pixel means the stream has loaded in the most
-      // user way we can verify it (pixel color)
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [85, 85, 85]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-    await test.step('opening broken code file should clear the scene and show the error', async () => {
-      // open the file pane.
-      await page.getByTestId('files-pane-button').click()
-
-      // OPen the other file.
-      const file = page.getByRole('button', { name: 'broken-code-test.kcl' })
-      await expect(file).toBeVisible()
-
-      await file.click()
-
-      // error in guter
-      await expect(page.locator('.cm-lint-marker-error')).toBeVisible()
-
-      // error text on hover
-      await page.hover('.cm-lint-marker-error')
-      const crypticErrorText = `Expected a tag declarator`
-      await expect(page.getByText(crypticErrorText).first()).toBeVisible()
-
-      // black pixel means the scene has been cleared.
-      await expect
-        .poll(() => u.getGreatestPixDiff(pointOnModel, [30, 30, 30]), {
-          timeout: 10_000,
-        })
-        .toBeLessThan(15)
-    })
-
-    await electronApp.close()
-  }
-)
-
 test(
   'when code with error first loads you get errors in console',
   { tag: '@electron' },

e2e/playwright/regression-tests.spec.ts

@@ -550,7 +550,7 @@ sketch001 = startSketchAt([-0, -0])
     const u = await getUtils(page)
 
     // Constants and locators
-    const planeColor: [number, number, number] = [161, 220, 155]
+    const planeColor: [number, number, number] = [170, 220, 170]
     const bgColor: [number, number, number] = [27, 27, 27]
     const middlePixelIsColor = async (color: [number, number, number]) => {
       return u.getGreatestPixDiff({ x: 600, y: 250 }, color)

e2e/playwright/secrets.ts

@@ -7,8 +7,6 @@ try {
     .split('\n')
     .filter((line) => line && line.length > 1)
     .forEach((line) => {
-      // Allow line comments.
-      if (line.trimStart().startsWith('#')) return
       const [key, value] = line.split('=')
       // prefer env vars over secrets file
       secrets[key] = process.env[key] || (value as any).replaceAll('"', '')

e2e/playwright/sketch-tests.spec.ts

@@ -943,110 +943,6 @@ sketch002 = startSketchOn(extrude001, 'END')
 `.replace(/\s/g, '')
     )
   })
-
-  /* TODO: once we fix bug turn on.
-   test('empty-scene default-planes act as expected when spaces in file', async ({
-    page,
-    browserName,
-  }) => {
-
-    const u = await getUtils(page)
-    await page.setViewportSize({ width: 1200, height: 500 })
-
-    await u.waitForAuthSkipAppStart()
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    const XYPlanePoint = { x: 774, y: 116 } as const
-    const unHoveredColor: [number, number, number] = [47, 47, 93]
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await page.mouse.move(XYPlanePoint.x, XYPlanePoint.y)
-    await page.waitForTimeout(200)
-
-    // color should not change for having been hovered
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await u.openAndClearDebugPanel()
-
-    // Fill with spaces
-    await u.codeLocator.fill(`               
-`)
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await page.mouse.move(XYPlanePoint.x, XYPlanePoint.y)
-    await page.waitForTimeout(200)
-
-    // color should not change for having been hovered
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-  })
-
-  test('empty-scene default-planes act as expected when only code comments in file', async ({
-    page,
-    browserName,
-  }) => {
-
-    const u = await getUtils(page)
-    await page.setViewportSize({ width: 1200, height: 500 })
-
-    await u.waitForAuthSkipAppStart()
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    const XYPlanePoint = { x: 774, y: 116 } as const
-    const unHoveredColor: [number, number, number] = [47, 47, 93]
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await page.mouse.move(XYPlanePoint.x, XYPlanePoint.y)
-    await page.waitForTimeout(200)
-
-    // color should not change for having been hovered
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await u.openAndClearDebugPanel()
-
-    // Fill with spaces
-    await u.codeLocator.fill(`// this is a code comments ya nerds
-`)
-
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-
-    await page.mouse.move(XYPlanePoint.x, XYPlanePoint.y)
-    await page.waitForTimeout(200)
-
-    // color should not change for having been hovered
-    expect(
-      await u.getGreatestPixDiff(XYPlanePoint, unHoveredColor)
-    ).toBeLessThan(8)
-  })*/
-
   test('empty-scene default-planes act as expected', async ({
     page,
     browserName,

e2e/playwright/snapshot-tests.spec.ts

@@ -950,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)
@@ -1164,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/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

@@ -26,17 +26,7 @@ test.describe('Testing constraints', () => {
     })
 
     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-perspective-toggle.spec.ts

@@ -23,7 +23,7 @@ test.describe('Test toggling perspective', () => {
       y: screenHeight * 0.4,
     }
     const backgroundColor: [number, number, number] = [29, 29, 29]
-    const xzPlaneColor: [number, number, number] = [82, 55, 96]
+    const xzPlaneColor: [number, number, number] = [50, 50, 99]
     const locationToHaveColor = async (color: [number, number, number]) => {
       return u.getGreatestPixDiff(checkedScreenLocation, color)
     }

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
         )

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",
@@ -80,7 +81,6 @@
     "simpleserver": "yarn pretest && http-server ./public --cors -p 3000",
     "simpleserver:ci": "yarn pretest && http-server ./public --cors -p 3000 &",
     "simpleserver:bg": "yarn pretest && http-server ./public --cors -p 3000 &",
-    "simpleserver:stop": "kill-port 3000",
     "fmt": "prettier --write ./src *.ts *.json *.js ./e2e ./packages",
     "fmt-check": "prettier --check ./src *.ts *.json *.js ./e2e ./packages",
     "fetch:wasm": "./get-latest-wasm-bundle.sh",
@@ -95,14 +95,14 @@
     "files:set-version": "echo \"$(jq --arg v \"$VERSION\" '.version=$v' package.json --indent 2)\" > package.json",
     "files:set-notes": "./scripts/set-files-notes.sh",
     "files:flip-to-nightly": "./scripts/flip-files-to-nightly.sh",
-    "files:invalidate-bucket": "./scripts/invalidate-files-bucket.sh",
-    "files:invalidate-bucket:nightly": "./scripts/invalidate-files-bucket.sh --nightly",
     "postinstall": "yarn fetch:samples && yarn xstate:typegen && ./node_modules/.bin/electron-rebuild",
     "xstate:typegen": "yarn xstate typegen \"src/**/*.ts?(x)\"",
     "make:dev": "make dev",
     "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,13 +145,19 @@
   "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",
     "@playwright/test": "^1.46.1",
     "@testing-library/jest-dom": "^5.14.1",
     "@testing-library/react": "^15.0.2",
@@ -164,7 +170,7 @@
     "@types/pixelmatch": "^5.2.6",
     "@types/pngjs": "^6.0.4",
     "@types/react": "^18.3.4",
-    "@types/react-dom": "^18.3.1",
+    "@types/react-dom": "^18.2.25",
     "@types/react-modal": "^3.16.3",
     "@types/three": "^0.163.0",
     "@types/ua-parser-js": "^0.7.39",
@@ -178,9 +184,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",
@@ -201,11 +207,12 @@
     "ts-node": "^10.0.0",
     "typescript": "^5.7.2",
     "vite": "^5.4.6",
+    "vite-plugin-eslint": "^1.8.1",
     "vite-plugin-package-version": "^1.1.0",
     "vite-tsconfig-paths": "^4.3.2",
     "vitest": "^1.6.0",
     "vitest-webgl-canvas-mock": "^1.1.0",
-    "wasm-pack": "^0.13.1",
+    "wasm-pack": "^0.13.0",
     "ws": "^8.17.0",
     "yarn": "^1.22.22"
   }

public/kcl-samples-manifest-fallback.json

@@ -149,6 +149,11 @@
     "title": "Tire",
     "description": "A tire is a critical component of a vehicle that provides the necessary traction and grip between the car and the road. It supports the vehicle's weight and absorbs shocks from road irregularities."
   },
+  {
+    "file": "wall-e.kcl",
+    "title": "WALL-E",
+    "description": "An inquisitive trash compacting robot imagined by Disney Pixar Animation Studios"
+  },
   {
     "file": "washer.kcl",
     "title": "Washer",

scripts/get-nightly-changelog.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-echo "## What's Changed"
-git log ${PREVIOUS_TAG}..HEAD --oneline --pretty=format:%s | grep -v Bump | awk '{print "* "toupper(substr($0,0,1))substr($0,2)}'
-echo ""
-echo "**Full Changelog**: https://github.com/KittyCAD/modeling-app/compare/${PREVIOUS_TAG}...${TAG}"

scripts/invalidate-files-bucket.sh

@@ -1,11 +0,0 @@
-#!/bin/bash
-base_dir="/releases/modeling-app"
-if [[ $1 = "--nightly" ]]; then
-    base_dir="/releases/modeling-app/nightly"
-fi
-
-echo "Invalidating json and yml files at $base_dir in the download bucket"
-gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="$base_dir/last_download.json" --async
-gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="$base_dir/latest-linux-arm64.yml" --async
-gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="$base_dir/latest-mac.yml" --async
-gcloud compute url-maps invalidate-cdn-cache dl-url-map --path="$base_dir/latest.yml" --async

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() {
@@ -155,6 +155,7 @@ export class CameraControls {
       this.camera.zoom = camProps.zoom || 1
     }
     this.camera.updateProjectionMatrix()
+    console.log('doing this thing', camProps)
     this.update(true)
   }
 
@@ -272,26 +273,14 @@ export class CameraControls {
         camSettings.center.y,
         camSettings.center.z
       )
-      const orientation = new Quaternion(
+      const quat = new Quaternion(
         camSettings.orientation.x,
         camSettings.orientation.y,
         camSettings.orientation.z,
         camSettings.orientation.w
       ).invert()
 
-      const newUp = new Vector3(
-        camSettings.up.x,
-        camSettings.up.y,
-        camSettings.up.z
-      )
-      this.camera.quaternion.set(
-        orientation.x,
-        orientation.y,
-        orientation.z,
-        orientation.w
-      )
-      this.camera.up.copy(newUp)
-      this.camera.updateProjectionMatrix()
+      this.camera.up.copy(new Vector3(0, 1, 0).applyQuaternion(quat))
       if (this.camera instanceof PerspectiveCamera && camSettings.ortho) {
         this.useOrthographicCamera()
       }
@@ -1175,7 +1164,7 @@ export class CameraControls {
       this.camera.updateProjectionMatrix()
     }
 
-    if (this.syncDirection === 'clientToEngine' || forceUpdate) {
+    if (this.syncDirection === 'clientToEngine' || forceUpdate)
       this.throttledUpdateEngineCamera({
         quaternion: this.camera.quaternion,
         position: this.camera.position,
@@ -1183,7 +1172,6 @@ export class CameraControls {
         isPerspective: this.isPerspective,
         target: this.target,
       })
-    }
     this.deferReactUpdate(this.reactCameraProperties)
     Object.values(this._camChangeCallbacks).forEach((cb) => cb())
   }

src/clientSideScene/ClientSideSceneComp.tsx

@@ -29,9 +29,6 @@ import {
   Expr,
   parse,
   recast,
-  defaultSourceRange,
-  resultIsOk,
-  ProgramMemory,
 } from 'lang/wasm'
 import { CustomIcon, CustomIconName } from 'components/CustomIcon'
 import { ConstrainInfo } from 'lang/std/stdTypes'
@@ -415,15 +412,14 @@ export async function deleteSegment({
   if (err(modifiedAst)) return Promise.reject(modifiedAst)
 
   const newCode = recast(modifiedAst)
-  const pResult = parse(newCode)
-  if (err(pResult) || !resultIsOk(pResult)) return Promise.reject(pResult)
-  modifiedAst = pResult.program
+  modifiedAst = parse(newCode)
+  if (err(modifiedAst)) return Promise.reject(modifiedAst)
 
   const testExecute = await executeAst({
     ast: modifiedAst,
+    idGenerator: kclManager.execState.idGenerator,
+    useFakeExecutor: true,
     engineCommandManager: engineCommandManager,
-    // We make sure to send an empty program memory to denote we mean mock mode.
-    programMemoryOverride: ProgramMemory.empty(),
   })
   if (testExecute.errors.length) {
     toast.error('Segment tag used outside of current Sketch. Could not delete.')
@@ -505,8 +501,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
@@ -595,9 +590,7 @@ const ConstraintSymbol = ({
   if (err(_node)) return
   const node = _node.node
 
-  const range: SourceRange = node
-    ? [node.start, node.end, true]
-    : defaultSourceRange()
+  const range: SourceRange = node ? [node.start, node.end] : [0, 0]
 
   if (_type === 'intersectionTag') return null
 
@@ -619,34 +612,25 @@ const ConstraintSymbol = ({
           editorManager.setHighlightRange([range])
         }}
         onMouseLeave={() => {
-          editorManager.setHighlightRange([defaultSourceRange()])
+          editorManager.setHighlightRange([[0, 0]])
         }}
         // disabled={isConstrained || !convertToVarEnabled}
         // 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) {
             try {
-              const pResult = parse(recast(kclManager.ast))
-              if (trap(pResult) || !resultIsOk(pResult))
-                return Promise.reject(pResult)
-
+              const parsed = parse(recast(kclManager.ast))
+              if (trap(parsed)) return Promise.reject(parsed)
               const _node1 = getNodeFromPath<CallExpression>(
-                pResult.program!,
+                parsed,
                 pathToNode,
                 'CallExpression',
                 true

src/clientSideScene/sceneEntities.ts

@@ -48,9 +48,6 @@ import {
   VariableDeclarator,
   sketchFromKclValue,
   sketchFromKclValueOptional,
-  defaultSourceRange,
-  sourceRangeFromRust,
-  resultIsOk,
 } from 'lang/wasm'
 import {
   engineCommandManager,
@@ -498,9 +495,10 @@ export class SceneEntities {
 
     const { execState } = await executeAst({
       ast: truncatedAst,
+      useFakeExecutor: true,
       engineCommandManager: this.engineCommandManager,
-      // We make sure to send an empty program memory to denote we mean mock mode.
       programMemoryOverride,
+      idGenerator: kclManager.execState.idGenerator,
     })
     const programMemory = execState.memory
     const sketch = sketchFromPathToNode({
@@ -532,7 +530,7 @@ export class SceneEntities {
 
     const segPathToNode = getNodePathFromSourceRange(
       maybeModdedAst,
-      sourceRangeFromRust(sketch.start.__geoMeta.sourceRange)
+      sketch.start.__geoMeta.sourceRange
     )
     if (sketch?.paths?.[0]?.type !== 'Circle') {
       const _profileStart = createProfileStartHandle({
@@ -554,7 +552,7 @@ export class SceneEntities {
     sketch.paths.forEach((segment, index) => {
       let segPathToNode = getNodePathFromSourceRange(
         maybeModdedAst,
-        sourceRangeFromRust(segment.__geoMeta.sourceRange)
+        segment.__geoMeta.sourceRange
       )
       if (
         draftExpressionsIndices &&
@@ -563,12 +561,12 @@ export class SceneEntities {
         const previousSegment = sketch.paths[index - 1] || sketch.start
         const previousSegmentPathToNode = getNodePathFromSourceRange(
           maybeModdedAst,
-          sourceRangeFromRust(previousSegment.__geoMeta.sourceRange)
+          previousSegment.__geoMeta.sourceRange
         )
         const bodyIndex = previousSegmentPathToNode[1][0]
         segPathToNode = getNodePathFromSourceRange(
           truncatedAst,
-          sourceRangeFromRust(segment.__geoMeta.sourceRange)
+          segment.__geoMeta.sourceRange
         )
         segPathToNode[1][0] = bodyIndex
       }
@@ -577,10 +575,7 @@ export class SceneEntities {
         index <= draftExpressionsIndices.end &&
         index >= draftExpressionsIndices.start
       const isSelected = selectionRanges?.graphSelections.some((selection) =>
-        isOverlap(
-          selection?.codeRef?.range,
-          sourceRangeFromRust(segment.__geoMeta.sourceRange)
-        )
+        isOverlap(selection?.codeRef?.range, segment.__geoMeta.sourceRange)
       )
 
       let seg: Group
@@ -662,11 +657,13 @@ export class SceneEntities {
   }
   updateAstAndRejigSketch = async (
     sketchPathToNode: PathToNode,
-    modifiedAst: Node<Program>,
+    modifiedAst: Node<Program> | Error,
     forward: [number, number, number],
     up: [number, number, number],
     origin: [number, number, number]
   ) => {
+    if (err(modifiedAst)) return modifiedAst
+
     const nextAst = await kclManager.updateAst(modifiedAst, false)
     await this.tearDownSketch({ removeAxis: false })
     sceneInfra.resetMouseListeners()
@@ -701,7 +698,8 @@ export class SceneEntities {
       'VariableDeclaration'
     )
     if (trap(_node1)) return Promise.reject(_node1)
-    const variableDeclarationName = _node1.node?.declaration.id?.name || ''
+    const variableDeclarationName =
+      _node1.node?.declarations?.[0]?.id?.name || ''
 
     const sg = sketchFromKclValue(
       kclManager.programMemory.get(variableDeclarationName),
@@ -723,9 +721,8 @@ export class SceneEntities {
       pathToNode: sketchPathToNode,
     })
     if (trap(mod)) return Promise.reject(mod)
-    const pResult = parse(recast(mod.modifiedAst))
-    if (trap(pResult) || !resultIsOk(pResult)) return Promise.reject(pResult)
-    const modifiedAst = pResult.program
+    const modifiedAst = parse(recast(mod.modifiedAst))
+    if (trap(modifiedAst)) return Promise.reject(modifiedAst)
 
     const draftExpressionsIndices = { start: index, end: index }
 
@@ -901,9 +898,10 @@ export class SceneEntities {
       'VariableDeclaration'
     )
     if (trap(_node1)) return Promise.reject(_node1)
-    const variableDeclarationName = _node1.node?.declaration.id?.name || ''
-    const startSketchOn = _node1.node?.declaration
-    const startSketchOnInit = startSketchOn?.init
+    const variableDeclarationName =
+      _node1.node?.declarations?.[0]?.id?.name || ''
+    const startSketchOn = _node1.node?.declarations
+    const startSketchOnInit = startSketchOn?.[0]?.init
 
     const tags: [string, string, string] = [
       findUniqueName(_ast, 'rectangleSegmentA'),
@@ -911,14 +909,14 @@ export class SceneEntities {
       findUniqueName(_ast, 'rectangleSegmentC'),
     ]
 
-    startSketchOn.init = createPipeExpression([
+    startSketchOn[0].init = createPipeExpression([
       startSketchOnInit,
       ...getRectangleCallExpressions(rectangleOrigin, tags),
     ])
 
-    const pResult = parse(recast(_ast))
-    if (trap(pResult) || !resultIsOk(pResult)) return Promise.reject(pResult)
-    _ast = pResult.program
+    let _recastAst = parse(recast(_ast))
+    if (trap(_recastAst)) return Promise.reject(_recastAst)
+    _ast = _recastAst
 
     const { programMemoryOverride, truncatedAst } = await this.setupSketch({
       sketchPathToNode,
@@ -941,7 +939,7 @@ export class SceneEntities {
           'VariableDeclaration'
         )
         if (trap(_node)) return Promise.reject(_node)
-        const sketchInit = _node.node?.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         const x = (args.intersectionPoint.twoD.x || 0) - rectangleOrigin[0]
         const y = (args.intersectionPoint.twoD.y || 0) - rectangleOrigin[1]
@@ -952,9 +950,10 @@ export class SceneEntities {
 
         const { execState } = await executeAst({
           ast: truncatedAst,
+          useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
-          // We make sure to send an empty program memory to denote we mean mock mode.
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
         const programMemory = execState.memory
         this.sceneProgramMemory = programMemory
@@ -990,7 +989,7 @@ export class SceneEntities {
           'VariableDeclaration'
         )
         if (trap(_node)) return
-        const sketchInit = _node.node?.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         if (sketchInit.type !== 'PipeExpression') {
           return
@@ -999,10 +998,9 @@ export class SceneEntities {
         updateRectangleSketch(sketchInit, x, y, tags[0])
 
         const newCode = recast(_ast)
-        const pResult = parse(newCode)
-        if (trap(pResult) || !resultIsOk(pResult))
-          return Promise.reject(pResult)
-        _ast = pResult.program
+        let _recastAst = parse(newCode)
+        if (trap(_recastAst)) return
+        _ast = _recastAst
 
         // Update the primary AST and unequip the rectangle tool
         await kclManager.executeAstMock(_ast)
@@ -1015,9 +1013,10 @@ export class SceneEntities {
 
         const { execState } = await executeAst({
           ast: _ast,
+          useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
-          // We make sure to send an empty program memory to denote we mean mock mode.
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
         const programMemory = execState.memory
 
@@ -1056,9 +1055,10 @@ export class SceneEntities {
     if (trap(_node1)) return Promise.reject(_node1)
 
     // startSketchOn already exists
-    const variableDeclarationName = _node1.node?.declaration.id?.name || ''
-    const startSketchOn = _node1.node?.declaration
-    const startSketchOnInit = startSketchOn?.init
+    const variableDeclarationName =
+      _node1.node?.declarations?.[0]?.id?.name || ''
+    const startSketchOn = _node1.node?.declarations
+    const startSketchOnInit = startSketchOn?.[0]?.init
 
     const tags: [string, string, string] = [
       findUniqueName(_ast, 'rectangleSegmentA'),
@@ -1066,14 +1066,14 @@ export class SceneEntities {
       findUniqueName(_ast, 'rectangleSegmentC'),
     ]
 
-    startSketchOn.init = createPipeExpression([
+    startSketchOn[0].init = createPipeExpression([
       startSketchOnInit,
       ...getRectangleCallExpressions(rectangleOrigin, tags),
     ])
 
-    const pResult = parse(recast(_ast))
-    if (trap(pResult) || !resultIsOk(pResult)) return Promise.reject(pResult)
-    _ast = pResult.program
+    let _recastAst = parse(recast(_ast))
+    if (trap(_recastAst)) return Promise.reject(_recastAst)
+    _ast = _recastAst
 
     const { programMemoryOverride, truncatedAst } = await this.setupSketch({
       sketchPathToNode,
@@ -1096,7 +1096,7 @@ export class SceneEntities {
           'VariableDeclaration'
         )
         if (trap(_node)) return Promise.reject(_node)
-        const sketchInit = _node.node?.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         const x = (args.intersectionPoint.twoD.x || 0) - rectangleOrigin[0]
         const y = (args.intersectionPoint.twoD.y || 0) - rectangleOrigin[1]
@@ -1114,9 +1114,10 @@ export class SceneEntities {
 
         const { execState } = await executeAst({
           ast: truncatedAst,
+          useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
-          // We make sure to send an empty program memory to denote we mean mock mode.
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
         const programMemory = execState.memory
         this.sceneProgramMemory = programMemory
@@ -1152,7 +1153,7 @@ export class SceneEntities {
           'VariableDeclaration'
         )
         if (trap(_node)) return
-        const sketchInit = _node.node?.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         if (sketchInit.type === 'PipeExpression') {
           updateCenterRectangleSketch(
@@ -1164,10 +1165,9 @@ export class SceneEntities {
             rectangleOrigin[1]
           )
 
-          const pResult = parse(recast(_ast))
-          if (trap(pResult) || !resultIsOk(pResult))
-            return Promise.reject(pResult)
-          _ast = pResult.program
+          let _recastAst = parse(recast(_ast))
+          if (trap(_recastAst)) return
+          _ast = _recastAst
 
           // Update the primary AST and unequip the rectangle tool
           await kclManager.executeAstMock(_ast)
@@ -1180,9 +1180,10 @@ export class SceneEntities {
 
           const { execState } = await executeAst({
             ast: _ast,
+            useFakeExecutor: true,
             engineCommandManager: this.engineCommandManager,
-            // We make sure to send an empty program memory to denote we mean mock mode.
             programMemoryOverride,
+            idGenerator: kclManager.execState.idGenerator,
           })
           const programMemory = execState.memory
 
@@ -1221,11 +1222,12 @@ export class SceneEntities {
       'VariableDeclaration'
     )
     if (trap(_node1)) return Promise.reject(_node1)
-    const variableDeclarationName = _node1.node?.declaration.id?.name || ''
-    const startSketchOn = _node1.node?.declaration
-    const startSketchOnInit = startSketchOn?.init
+    const variableDeclarationName =
+      _node1.node?.declarations?.[0]?.id?.name || ''
+    const startSketchOn = _node1.node?.declarations
+    const startSketchOnInit = startSketchOn?.[0]?.init
 
-    startSketchOn.init = createPipeExpression([
+    startSketchOn[0].init = createPipeExpression([
       startSketchOnInit,
       createCallExpressionStdLib('circle', [
         createObjectExpression({
@@ -1239,9 +1241,9 @@ export class SceneEntities {
       ]),
     ])
 
-    const pResult = parse(recast(_ast))
-    if (trap(pResult) || !resultIsOk(pResult)) return Promise.reject(pResult)
-    _ast = pResult.program
+    let _recastAst = parse(recast(_ast))
+    if (trap(_recastAst)) return Promise.reject(_recastAst)
+    _ast = _recastAst
 
     // do a quick mock execution to get the program memory up-to-date
     await kclManager.executeAstMock(_ast)
@@ -1267,7 +1269,7 @@ export class SceneEntities {
         )
         let modded = structuredClone(truncatedAst)
         if (trap(_node)) return
-        const sketchInit = _node.node.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         const x = (args.intersectionPoint.twoD.x || 0) - circleCenter[0]
         const y = (args.intersectionPoint.twoD.y || 0) - circleCenter[1]
@@ -1297,9 +1299,10 @@ export class SceneEntities {
 
         const { execState } = await executeAst({
           ast: modded,
+          useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
-          // We make sure to send an empty program memory to denote we mean mock mode.
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
         const programMemory = execState.memory
         this.sceneProgramMemory = programMemory
@@ -1335,7 +1338,7 @@ export class SceneEntities {
           'VariableDeclaration'
         )
         if (trap(_node)) return
-        const sketchInit = _node.node?.declaration.init
+        const sketchInit = _node.node?.declarations?.[0]?.init
 
         let modded = structuredClone(_ast)
         if (sketchInit.type === 'PipeExpression') {
@@ -1362,10 +1365,9 @@ export class SceneEntities {
 
           const newCode = recast(modded)
           if (err(newCode)) return
-          const pResult = parse(newCode)
-          if (trap(pResult) || !resultIsOk(pResult))
-            return Promise.reject(pResult)
-          _ast = pResult.program
+          let _recastAst = parse(newCode)
+          if (trap(_recastAst)) return Promise.reject(_recastAst)
+          _ast = _recastAst
 
           // Update the primary AST and unequip the rectangle tool
           await kclManager.executeAstMock(_ast)
@@ -1658,7 +1660,7 @@ export class SceneEntities {
         kclManager.programMemory,
         {
           type: 'sourceRange',
-          sourceRange: [node.start, node.end, true],
+          sourceRange: [node.start, node.end],
         },
         getChangeSketchInput()
       )
@@ -1681,9 +1683,10 @@ export class SceneEntities {
         codeManager.updateCodeEditor(code)
       const { execState } = await executeAst({
         ast: truncatedAst,
+        useFakeExecutor: true,
         engineCommandManager: this.engineCommandManager,
-        // We make sure to send an empty program memory to denote we mean mock mode.
         programMemoryOverride,
+        idGenerator: kclManager.execState.idGenerator,
       })
       const programMemory = execState.memory
       this.sceneProgramMemory = programMemory
@@ -1747,7 +1750,7 @@ export class SceneEntities {
   ): (() => SegmentOverlayPayload | null) => {
     const segPathToNode = getNodePathFromSourceRange(
       modifiedAst,
-      sourceRangeFromRust(segment.__geoMeta.sourceRange)
+      segment.__geoMeta.sourceRange
     )
     const sgPaths = sketch.paths
     const originalPathToNodeStr = JSON.stringify(segPathToNode)
@@ -1898,10 +1901,8 @@ export class SceneEntities {
           SEGMENT_BODIES_PLUS_PROFILE_START
         )
         if (parent?.userData?.pathToNode) {
-          const pResult = parse(recast(kclManager.ast))
-          if (trap(pResult) || !resultIsOk(pResult))
-            return Promise.reject(pResult)
-          const updatedAst = pResult.program
+          const updatedAst = parse(recast(kclManager.ast))
+          if (trap(updatedAst)) return
           const _node = getNodeFromPath<Node<CallExpression>>(
             updatedAst,
             parent.userData.pathToNode,
@@ -1909,7 +1910,7 @@ export class SceneEntities {
           )
           if (trap(_node, { suppress: true })) return
           const node = _node.node
-          editorManager.setHighlightRange([[node.start, node.end, true]])
+          editorManager.setHighlightRange([[node.start, node.end]])
           const yellow = 0xffff00
           colorSegment(selected, yellow)
           const extraSegmentGroup = parent.getObjectByName(EXTRA_SEGMENT_HANDLE)
@@ -1954,10 +1955,10 @@ export class SceneEntities {
             })
           return
         }
-        editorManager.setHighlightRange([defaultSourceRange()])
+        editorManager.setHighlightRange([[0, 0]])
       },
       onMouseLeave: ({ selected, ...rest }: OnMouseEnterLeaveArgs) => {
-        editorManager.setHighlightRange([defaultSourceRange()])
+        editorManager.setHighlightRange([[0, 0]])
         const parent = getParentGroup(
           selected,
           SEGMENT_BODIES_PLUS_PROFILE_START
@@ -2056,7 +2057,7 @@ function prepareTruncatedMemoryAndAst(
     'VariableDeclaration'
   )
   if (err(_node)) return _node
-  const variableDeclarationName = _node.node?.declaration.id?.name || ''
+  const variableDeclarationName = _node.node?.declarations?.[0]?.id?.name || ''
   const sg = sketchFromKclValue(
     programMemory.get(variableDeclarationName),
     variableDeclarationName
@@ -2081,30 +2082,28 @@ function prepareTruncatedMemoryAndAst(
       ])
     }
     ;(
-      (_ast.body[bodyIndex] as VariableDeclaration).declaration
+      (_ast.body[bodyIndex] as VariableDeclaration).declarations[0]
         .init as PipeExpression
     ).body.push(newSegment)
     // update source ranges to section we just added.
     // hacks like this wouldn't be needed if the AST put pathToNode info in memory/sketch segments
-    const pResult = parse(recast(_ast)) // get source ranges correct since unfortunately we still rely on them
-    if (trap(pResult) || !resultIsOk(pResult))
-      return Error('Unexpected compilation error')
-    const updatedSrcRangeAst = pResult.program
+    const updatedSrcRangeAst = parse(recast(_ast)) // get source ranges correct since unfortunately we still rely on them
+    if (err(updatedSrcRangeAst)) return updatedSrcRangeAst
 
     const lastPipeItem = (
-      (updatedSrcRangeAst.body[bodyIndex] as VariableDeclaration).declaration
-        .init as PipeExpression
+      (updatedSrcRangeAst.body[bodyIndex] as VariableDeclaration)
+        .declarations[0].init as PipeExpression
     ).body.slice(-1)[0]
 
     ;(
-      (_ast.body[bodyIndex] as VariableDeclaration).declaration
+      (_ast.body[bodyIndex] as VariableDeclaration).declarations[0]
         .init as PipeExpression
     ).body.slice(-1)[0].start = lastPipeItem.start
 
     _ast.end = lastPipeItem.end
     const varDec = _ast.body[bodyIndex] as Node<VariableDeclaration>
     varDec.end = lastPipeItem.end
-    const declarator = varDec.declaration
+    const declarator = varDec.declarations[0]
     declarator.end = lastPipeItem.end
     const init = declarator.init as Node<PipeExpression>
     init.end = lastPipeItem.end
@@ -2141,7 +2140,7 @@ function prepareTruncatedMemoryAndAst(
     if (node.type !== 'VariableDeclaration') {
       continue
     }
-    const name = node.declaration.id.name
+    const name = node.declarations[0].id.name
     const memoryItem = programMemory.get(name)
     if (!memoryItem) {
       continue

src/components/AstExplorer.tsx

@@ -5,7 +5,6 @@ import { useEffect, useRef, useState } from 'react'
 import { trap } from 'lib/trap'
 import { codeToIdSelections } from 'lib/selections'
 import { codeRefFromRange } from 'lang/std/artifactGraph'
-import { defaultSourceRange } from 'lang/wasm'
 
 export function AstExplorer() {
   const { context } = useModelingContext()
@@ -47,7 +46,7 @@ export function AstExplorer() {
       <div
         className="h-full relative"
         onMouseLeave={(e) => {
-          editorManager.setHighlightRange([defaultSourceRange()])
+          editorManager.setHighlightRange([[0, 0]])
         }}
       >
         <pre className="text-xs">
@@ -116,19 +115,15 @@ function DisplayObj({
         hasCursor ? 'bg-violet-100/80 dark:bg-violet-100/25' : ''
       }`}
       onMouseEnter={(e) => {
-        editorManager.setHighlightRange([[obj?.start || 0, obj.end, true]])
+        editorManager.setHighlightRange([[obj?.start || 0, obj.end]])
         e.stopPropagation()
       }}
       onMouseMove={(e) => {
         e.stopPropagation()
-        editorManager.setHighlightRange([[obj?.start || 0, obj.end, true]])
+        editorManager.setHighlightRange([[obj?.start || 0, obj.end]])
       }}
       onClick={(e) => {
-        const range: [number, number, boolean] = [
-          obj?.start || 0,
-          obj.end || 0,
-          true,
-        ]
+        const range: [number, number] = [obj?.start || 0, obj.end || 0]
         const idInfo = codeToIdSelections([
           { codeRef: codeRefFromRange(range, kclManager.ast) },
         ])[0]

src/components/AvailableVarsHelpers.tsx

@@ -1,11 +1,5 @@
 import { useEffect, useState, useRef } from 'react'
-import {
-  parse,
-  BinaryPart,
-  Expr,
-  ProgramMemory,
-  resultIsOk,
-} from '../lang/wasm'
+import { parse, BinaryPart, Expr, ProgramMemory } from '../lang/wasm'
 import {
   createIdentifier,
   createLiteral,
@@ -147,9 +141,8 @@ export function useCalc({
   useEffect(() => {
     try {
       const code = `const __result__ = ${value}`
-      const pResult = parse(code)
-      if (trap(pResult) || !resultIsOk(pResult)) return
-      const ast = pResult.program
+      const ast = parse(code)
+      if (trap(ast)) return
       const _programMem: ProgramMemory = ProgramMemory.empty()
       for (const { key, value } of availableVarInfo.variables) {
         const error = _programMem.set(key, {
@@ -163,17 +156,18 @@ export function useCalc({
       executeAst({
         ast,
         engineCommandManager,
-        // We make sure to send an empty program memory to denote we mean mock mode.
+        useFakeExecutor: true,
         programMemoryOverride: kclManager.programMemory.clone(),
+        idGenerator: kclManager.execState.idGenerator,
       }).then(({ execState }) => {
         const resultDeclaration = ast.body.find(
           (a) =>
             a.type === 'VariableDeclaration' &&
-            a.declaration.id?.name === '__result__'
+            a.declarations?.[0]?.id?.name === '__result__'
         )
         const init =
           resultDeclaration?.type === 'VariableDeclaration' &&
-          resultDeclaration?.declaration.init
+          resultDeclaration?.declarations?.[0]?.init
         const result = execState.memory?.get('__result__')?.value
         setCalcResult(typeof result === 'number' ? String(result) : 'NAN')
         init && setValueNode(init)

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/FileTree.tsx

@@ -266,7 +266,6 @@ const FileTreeItem = ({
       // Let the lsp servers know we closed a file.
       onFileClose(currentFile?.path || null, project?.path || null)
       onFileOpen(fileOrDir.path, project?.path || null)
-      kclManager.switchedFiles = true
 
       // Open kcl files
       navigate(`${PATHS.FILE}/${encodeURIComponent(fileOrDir.path)}`)

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

@@ -41,10 +41,7 @@ import {
   angleBetweenInfo,
   applyConstraintAngleBetween,
 } from './Toolbar/SetAngleBetween'
-import {
-  applyConstraintAngleLength,
-  applyConstraintLength,
-} from './Toolbar/setAngleLength'
+import { applyConstraintAngleLength } from './Toolbar/setAngleLength'
 import {
   canSweepSelection,
   handleSelectionBatch,
@@ -53,9 +50,6 @@ import {
   isSketchPipe,
   Selections,
   updateSelections,
-  canLoftSelection,
-  canRevolveSelection,
-  canShellSelection,
 } from 'lib/selections'
 import { applyConstraintIntersect } from './Toolbar/Intersect'
 import { applyConstraintAbsDistance } from './Toolbar/SetAbsDistance'
@@ -67,15 +61,13 @@ import {
   getSketchOrientationDetails,
 } from 'clientSideScene/sceneEntities'
 import {
-  insertNamedConstant,
-  replaceValueAtNodePath,
+  moveValueIntoNewVariablePath,
   sketchOnExtrudedFace,
   sketchOnOffsetPlane,
   startSketchOnDefault,
 } from 'lang/modifyAst'
-import { PathToNode, Program, parse, recast, resultIsOk } from 'lang/wasm'
+import { Program, parse, recast } from 'lang/wasm'
 import {
-  doesSceneHaveExtrudedSketch,
   doesSceneHaveSweepableSketch,
   getNodePathFromSourceRange,
   isSingleCursorInPipe,
@@ -86,10 +78,11 @@ 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 { 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'
+import { hasValidEdgeTreatmentSelection } from 'lang/modifyAst/addFillet'
 import {
   ExportIntent,
   EngineConnectionStateType,
@@ -576,59 +569,6 @@ export const ModelingMachineProvider = ({
           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
-            // BUT only if there's extrudable geometry
-            return doesSceneHaveSweepableSketch(kclManager.ast)
-          }
-          if (!isSketchPipe(selectionRanges)) return false
-
-          const canSweep = canRevolveSelection(selectionRanges)
-          if (err(canSweep)) return false
-          return canSweep
-        },
-        'has valid loft selection': ({ context: { selectionRanges } }) => {
-          const hasNoSelection =
-            selectionRanges.graphSelections.length === 0 ||
-            isRangeBetweenCharacters(selectionRanges) ||
-            isSelectionLastLine(selectionRanges, codeManager.code)
-
-          if (hasNoSelection) {
-            const count = 2
-            return doesSceneHaveSweepableSketch(kclManager.ast, count)
-          }
-
-          const canLoft = canLoftSelection(selectionRanges)
-          if (err(canLoft)) return false
-          return canLoft
-        },
-        'has valid shell selection': ({
-          context: { selectionRanges },
-          event,
-        }) => {
-          const hasNoSelection =
-            selectionRanges.graphSelections.length === 0 ||
-            isRangeBetweenCharacters(selectionRanges) ||
-            isSelectionLastLine(selectionRanges, codeManager.code)
-
-          if (hasNoSelection) {
-            return doesSceneHaveExtrudedSketch(kclManager.ast)
-          }
-
-          const canShell = canShellSelection(selectionRanges)
-          console.log('canShellSelection', canShellSelection(selectionRanges))
-          if (err(canShell)) return false
-          return canShell
-        },
         'has valid selection for deletion': ({
           context: { selectionRanges },
         }) => {
@@ -656,11 +596,15 @@ export const ModelingMachineProvider = ({
           )
         },
         'Has exportable geometry': () => {
-          if (!kclManager.hasErrors() && kclManager.ast.body.length > 0)
+          if (
+            kclManager.kclErrors.length === 0 &&
+            kclManager.ast.body.length > 0
+          )
             return true
           else {
             let errorMessage = 'Unable to Export '
-            if (kclManager.hasErrors()) errorMessage += 'due to KCL Errors'
+            if (kclManager.kclErrors.length > 0)
+              errorMessage += 'due to KCL Errors'
             else if (kclManager.ast.body.length === 0)
               errorMessage += 'due to Empty Scene'
             console.error(errorMessage)
@@ -778,11 +722,7 @@ export const ModelingMachineProvider = ({
                 constraint: 'setHorzDistance',
                 selectionRanges,
               })
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
-
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -823,10 +763,7 @@ export const ModelingMachineProvider = ({
                 constraint: 'setVertDistance',
                 selectionRanges,
               })
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -874,10 +811,7 @@ export const ModelingMachineProvider = ({
                   selectionRanges,
                   angleOrLength: 'setAngle',
                 }))
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+            const _modifiedAst = parse(recast(modifiedAst))
             if (err(_modifiedAst)) return Promise.reject(_modifiedAst)
 
             if (!sketchDetails)
@@ -913,22 +847,13 @@ export const ModelingMachineProvider = ({
             }
           }
         ),
-        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 } = constraintResult
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+        'Get length info': fromPromise(
+          async ({ input: { selectionRanges, sketchDetails } }) => {
+            const { modifiedAst, pathToNodeMap } =
+              await applyConstraintAngleLength({
+                selectionRanges,
+              })
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -968,10 +893,7 @@ export const ModelingMachineProvider = ({
               await applyConstraintIntersect({
                 selectionRanges,
               })
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -1012,10 +934,7 @@ export const ModelingMachineProvider = ({
                 constraint: 'xAbs',
                 selectionRanges,
               })
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -1056,10 +975,7 @@ export const ModelingMachineProvider = ({
                 constraint: 'yAbs',
                 selectionRanges,
               })
-            const pResult = parse(recast(modifiedAst))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            const _modifiedAst = pResult.program
+            const _modifiedAst = parse(recast(modifiedAst))
             if (!sketchDetails)
               return Promise.reject(new Error('No sketch details'))
             const updatedPathToNode = updatePathToNodeFromMap(
@@ -1093,88 +1009,33 @@ export const ModelingMachineProvider = ({
             }
           }
         ),
-        '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'))
-            }
-            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
-            } = {
-              modifiedAst: parsed,
-              pathToReplaced: null,
-            }
-            // 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,
-                  })
-                )
-              )
-              if (
-                trap(parseResultAfterInsertion) ||
-                !resultIsOk(parseResultAfterInsertion)
-              )
-                return Promise.reject(parseResultAfterInsertion)
-              result = {
-                modifiedAst: parseResultAfterInsertion.program,
-                pathToReplaced: astAfterReplacement.pathToReplaced,
-              }
-            } 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))
-            if (trap(pResult) || !resultIsOk(pResult))
-              return Promise.reject(new Error('Unexpected compilation error'))
-            parsed = pResult.program
-
+            const { variableName } = await getVarNameModal({
+              valueName: data?.variableName || 'var',
+            })
+            let parsed = parse(recast(kclManager.ast))
             if (trap(parsed)) return Promise.reject(parsed)
             parsed = parsed as Node<Program>
-            if (!result.pathToReplaced)
+
+            const { modifiedAst: _modifiedAst, pathToReplacedNode } =
+              moveValueIntoNewVariablePath(
+                parsed,
+                kclManager.programMemory,
+                data?.pathToNode || [],
+                variableName
+              )
+            parsed = parse(recast(_modifiedAst))
+            if (trap(parsed)) return Promise.reject(parsed)
+            parsed = parsed as Node<Program>
+            if (!pathToReplacedNode)
               return Promise.reject(new Error('No path to replaced node'))
 
             const updatedAst =
               await sceneEntitiesManager.updateAstAndRejigSketch(
-                result.pathToReplaced || [],
+                pathToReplacedNode || [],
                 parsed,
                 sketchDetails.zAxis,
                 sketchDetails.yAxis,
@@ -1187,7 +1048,7 @@ export const ModelingMachineProvider = ({
             )
 
             const selection = updateSelections(
-              { 0: result.pathToReplaced },
+              { 0: pathToReplacedNode },
               selectionRanges,
               updatedAst.newAst
             )
@@ -1195,7 +1056,7 @@ export const ModelingMachineProvider = ({
             return {
               selectionType: 'completeSelection',
               selection,
-              updatedPathToNode: result.pathToReplaced,
+              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/ModelingSidebar/ModelingPanes/KclEditorMenu.tsx

@@ -40,9 +40,7 @@ export const KclEditorMenu = ({ children }: PropsWithChildren) => {
         <Menu.Items className="absolute right-0 left-auto w-72 flex flex-col gap-1 divide-y divide-chalkboard-20 dark:divide-chalkboard-70 align-stretch px-0 py-1 bg-chalkboard-10 dark:bg-chalkboard-100 rounded-sm shadow-lg border border-solid border-chalkboard-20/50 dark:border-chalkboard-80/50">
           <Menu.Item>
             <button
-              onClick={() => {
-                kclManager.format().catch(reportRejection)
-              }}
+              onClick={() => kclManager.format()}
               className={styles.button}
             >
               <span>Format code</span>

src/components/ModelingSidebar/ModelingPanes/MemoryPane.test.tsx

@@ -1,6 +1,6 @@
 import { processMemory } from './MemoryPane'
 import { enginelessExecutor } from '../../../lib/testHelpers'
-import { assertParse, initPromise, ProgramMemory } from '../../../lang/wasm'
+import { initPromise, parse, ProgramMemory } from '../../../lang/wasm'
 
 beforeAll(async () => {
   await initPromise
@@ -28,16 +28,12 @@ describe('processMemory', () => {
     |> lineTo([0.98, 5.16], %)
     |> lineTo([2.15, 4.32], %)
     // |> rx(90, %)`
-    const ast = assertParse(code)
+    const ast = parse(code)
     const execState = await enginelessExecutor(ast, ProgramMemory.empty())
     const output = processMemory(execState.memory)
     expect(output.myVar).toEqual(5)
     expect(output.otherVar).toEqual(3)
     expect(output).toEqual({
-      HALF_TURN: 180,
-      QUARTER_TURN: 90,
-      THREE_QUARTER_TURN: 270,
-      ZERO: 0,
       myVar: 5,
       myFn: '__function(a)__',
       otherVar: 3,

src/components/ModelingSidebar/ModelingPanes/index.tsx

@@ -90,7 +90,7 @@ export const sidebarPanes: SidebarPane[] = [
     keybinding: 'Shift + C',
     showBadge: {
       value: ({ kclContext }) => {
-        return kclContext.diagnostics.length
+        return kclContext.errors.length
       },
       onClick: (e) => {
         e.preventDefault()

src/components/ModelingSidebar/ModelingSidebar.tsx

@@ -53,7 +53,7 @@ export function ModelingSidebar({ paneOpacity }: ModelingSidebarProps) {
       settings: settings.context,
       platform: getPlatformString(),
     }),
-    [kclContext.diagnostics, settings.context]
+    [kclContext.errors, settings.context]
   )
 
   const sidebarActions: SidebarAction[] = [

src/components/ProjectSidebarMenu.tsx

@@ -10,7 +10,7 @@ import { APP_NAME } from 'lib/constants'
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { CustomIcon } from './CustomIcon'
 import { useLspContext } from './LspProvider'
-import { engineCommandManager, kclManager } from 'lib/singletons'
+import { engineCommandManager } from 'lib/singletons'
 import { MachineManagerContext } from 'components/MachineManagerProvider'
 import usePlatform from 'hooks/usePlatform'
 import { useAbsoluteFilePath } from 'hooks/useAbsoluteFilePath'
@@ -68,7 +68,8 @@ function AppLogoLink({
       data-testid="app-logo"
       onClick={() => {
         onProjectClose(file || null, project?.path || null, false)
-        kclManager.switchedFiles = true
+        // Clear the scene and end the session.
+        engineCommandManager.endSession()
       }}
       to={PATHS.HOME}
       className={wrapperClassName + ' hover:before:brightness-110'}
@@ -189,7 +190,8 @@ function ProjectMenuPopover({
           className: !isDesktop() ? 'hidden' : '',
           onClick: () => {
             onProjectClose(file || null, project?.path || null, true)
-            kclManager.switchedFiles = true
+            // Clear the scene and end the session.
+            engineCommandManager.endSession()
           },
         },
       ].filter(

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/RemoveConstrainingValues.tsx

@@ -40,10 +40,7 @@ export function removeConstrainingValuesInfo({
         otherSelections: [],
         graphSelections: nodes.map(
           (node): Selection => ({
-            codeRef: codeRefFromRange(
-              [node.start, node.end, true],
-              kclManager.ast
-            ),
+            codeRef: codeRefFromRange([node.start, node.end], kclManager.ast),
           })
         ),
       }

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,57 +63,6 @@ export function angleLengthInfo({
   return { enabled, transforms }
 }
 
-export async function applyConstraintLength({
-  length,
-  selectionRanges,
-}: {
-  length: KclCommandValue
-  selectionRanges: Selections
-}) {
-  const ast = kclManager.ast
-  const angleLength = angleLengthInfo({ selectionRanges })
-  if (err(angleLength)) return 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 new Error('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,
-  }
-}
-
 export async function applyConstraintAngleLength({
   selectionRanges,
   angleOrLength = 'setLength',

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/manager.ts

@@ -139,9 +139,7 @@ export default class EditorManager {
   }
 
   setHighlightRange(range: Array<Selection['codeRef']['range']>): void {
-    this._highlightRange = range.map((s): [number, number] => {
-      return [s[0], s[1]]
-    })
+    this._highlightRange = range
 
     const selectionsWithSafeEnds = range.map((s): [number, number] => {
       const safeEnd = Math.min(s[1], this._editorView?.state.doc.length || s[1])

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/useEngineConnectionSubscriptions.ts

@@ -18,7 +18,7 @@ import {
 import { err, reportRejection } from 'lib/trap'
 import { DefaultPlaneStr, getFaceDetails } from 'clientSideScene/sceneEntities'
 import { getNodeFromPath, getNodePathFromSourceRange } from 'lang/queryAst'
-import { CallExpression, defaultSourceRange } from 'lang/wasm'
+import { CallExpression } from 'lang/wasm'
 import { EdgeCutInfo, ExtrudeFacePlane } from 'machines/modelingMachine'
 
 export function useEngineConnectionSubscriptions() {
@@ -46,7 +46,7 @@ export function useEngineConnectionSubscriptions() {
           (editorManager.highlightRange[0][0] !== 0 &&
             editorManager.highlightRange[0][1] !== 0)
         ) {
-          editorManager.setHighlightRange([defaultSourceRange()])
+          editorManager.setHighlightRange([[0, 0]])
         }
       },
     })
@@ -201,7 +201,7 @@ export function useEngineConnectionSubscriptions() {
               const { z_axis, y_axis, origin } = faceInfo
               const sketchPathToNode = getNodePathFromSourceRange(
                 kclManager.ast,
-                err(codeRef) ? defaultSourceRange() : codeRef.range
+                err(codeRef) ? [0, 0] : codeRef.range
               )
 
               const getEdgeCutMeta = (): null | EdgeCutInfo => {

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/KclProvider.tsx

@@ -1,15 +1,15 @@
+import { KCLError } from './errors'
 import { createContext, useContext, useEffect, useState } from 'react'
 import { type IndexLoaderData } from 'lib/types'
 import { useLoaderData } from 'react-router-dom'
 import { codeManager, kclManager } from 'lib/singletons'
-import { Diagnostic } from '@codemirror/lint'
 
 const KclContext = createContext({
   code: codeManager?.code || '',
   programMemory: kclManager?.programMemory,
   ast: kclManager?.ast,
   isExecuting: kclManager?.isExecuting,
-  diagnostics: kclManager?.diagnostics,
+  errors: kclManager?.kclErrors,
   logs: kclManager?.logs,
   wasmInitFailed: kclManager?.wasmInitFailed,
 })
@@ -32,7 +32,7 @@ export function KclContextProvider({
   const [programMemory, setProgramMemory] = useState(kclManager.programMemory)
   const [ast, setAst] = useState(kclManager.ast)
   const [isExecuting, setIsExecuting] = useState(false)
-  const [diagnostics, setErrors] = useState<Diagnostic[]>([])
+  const [errors, setErrors] = useState<KCLError[]>([])
   const [logs, setLogs] = useState<string[]>([])
   const [wasmInitFailed, setWasmInitFailed] = useState(false)
 
@@ -57,7 +57,7 @@ export function KclContextProvider({
         programMemory,
         ast,
         isExecuting,
-        diagnostics,
+        errors,
         logs,
         wasmInitFailed,
       }}

src/lang/KclSingleton.ts

@@ -1,10 +1,6 @@
 import { executeAst, lintAst } from 'lang/langHelpers'
 import { Selections } from 'lib/selections'
-import {
-  KCLError,
-  complilationErrorsToDiagnostics,
-  kclErrorsToDiagnostics,
-} from './errors'
+import { KCLError, kclErrorsToDiagnostics } from './errors'
 import { uuidv4 } from 'lib/utils'
 import { EngineCommandManager } from './std/engineConnection'
 import { err } from 'lib/trap'
@@ -12,7 +8,6 @@ import { EXECUTE_AST_INTERRUPT_ERROR_MESSAGE } from 'lib/constants'
 
 import {
   CallExpression,
-  clearSceneAndBustCache,
   emptyExecState,
   ExecState,
   initPromise,
@@ -56,12 +51,11 @@ export class KclManager {
   private _programMemory: ProgramMemory = ProgramMemory.empty()
   lastSuccessfulProgramMemory: ProgramMemory = ProgramMemory.empty()
   private _logs: string[] = []
-  private _diagnostics: Diagnostic[] = []
+  private _lints: Diagnostic[] = []
+  private _kclErrors: KCLError[] = []
   private _isExecuting = false
   private _executeIsStale: ExecuteArgs | null = null
   private _wasmInitFailed = true
-  private _hasErrors = false
-  private _switchedFiles = false
 
   engineCommandManager: EngineCommandManager
 
@@ -69,7 +63,7 @@ export class KclManager {
   private _astCallBack: (arg: Node<Program>) => void = () => {}
   private _programMemoryCallBack: (arg: ProgramMemory) => void = () => {}
   private _logsCallBack: (arg: string[]) => void = () => {}
-  private _kclErrorsCallBack: (errors: Diagnostic[]) => void = () => {}
+  private _kclErrorsCallBack: (arg: KCLError[]) => void = () => {}
   private _wasmInitFailedCallback: (arg: boolean) => void = () => {}
   private _executeCallback: () => void = () => {}
 
@@ -81,10 +75,6 @@ export class KclManager {
     this._astCallBack(ast)
   }
 
-  set switchedFiles(switchedFiles: boolean) {
-    this._switchedFiles = switchedFiles
-  }
-
   get programMemory() {
     return this._programMemory
   }
@@ -94,7 +84,7 @@ export class KclManager {
     this._programMemoryCallBack(programMemory)
   }
 
-  private set execState(execState) {
+  set execState(execState) {
     this._execState = execState
     this.programMemory = execState.memory
   }
@@ -111,28 +101,38 @@ export class KclManager {
     this._logsCallBack(logs)
   }
 
-  get diagnostics() {
-    return this._diagnostics
+  get lints() {
+    return this._lints
   }
 
-  set diagnostics(ds) {
-    if (ds === this._diagnostics) return
-    this._diagnostics = ds
+  set lints(lints) {
+    if (lints === this._lints) return
+    this._lints = lints
+    // Run the lints through the diagnostics.
+    this.kclErrors = this._kclErrors
+  }
+
+  get kclErrors() {
+    return this._kclErrors
+  }
+  set kclErrors(kclErrors) {
+    if (kclErrors === this._kclErrors && this.lints.length === 0) return
+    this._kclErrors = kclErrors
     this.setDiagnosticsForCurrentErrors()
-  }
-
-  addDiagnostics(ds: Diagnostic[]) {
-    if (ds.length === 0) return
-    this.diagnostics = this.diagnostics.concat(ds)
-  }
-
-  hasErrors(): boolean {
-    return this._hasErrors
+    this._kclErrorsCallBack(kclErrors)
   }
 
   setDiagnosticsForCurrentErrors() {
-    editorManager?.setDiagnostics(this.diagnostics)
-    this._kclErrorsCallBack(this.diagnostics)
+    let diagnostics = kclErrorsToDiagnostics(this.kclErrors)
+    if (this.lints.length > 0) {
+      diagnostics = diagnostics.concat(this.lints)
+    }
+    editorManager?.setDiagnostics(diagnostics)
+  }
+
+  addKclErrors(kclErrors: KCLError[]) {
+    if (kclErrors.length === 0) return
+    this.kclErrors = this.kclErrors.concat(kclErrors)
   }
 
   get isExecuting() {
@@ -172,12 +172,8 @@ export class KclManager {
     this.engineCommandManager = engineCommandManager
 
     // eslint-disable-next-line @typescript-eslint/no-floating-promises
-    this.ensureWasmInit().then(async () => {
-      await this.safeParse(codeManager.code).then((ast) => {
-        if (ast) {
-          this.ast = ast
-        }
-      })
+    this.ensureWasmInit().then(() => {
+      this.ast = this.safeParse(codeManager.code) || this.ast
     })
   }
 
@@ -192,7 +188,7 @@ export class KclManager {
     setProgramMemory: (arg: ProgramMemory) => void
     setAst: (arg: Node<Program>) => void
     setLogs: (arg: string[]) => void
-    setKclErrors: (errors: Diagnostic[]) => void
+    setKclErrors: (arg: KCLError[]) => void
     setIsExecuting: (arg: boolean) => void
     setWasmInitFailed: (arg: boolean) => void
   }) {
@@ -221,48 +217,18 @@ export class KclManager {
     }
   }
 
-  // (jess) I'm not in love with this, but it ensures we clear the scene and
-  // bust the cache on
-  // errors from parsing when opening new files.
-  // Why not just clear the cache on all parse errors, you ask? well its actually
-  // really nice to keep the cache on parse errors within the same file, and
-  // only bust on engine errors esp if they take a long time to execute and
-  // you hit the wrong key!
-  private async checkIfSwitchedFilesShouldClear() {
-    // If we were switching files and we hit an error on parse we need to bust
-    // the cache and clear the scene.
-    if (this._hasErrors && this._switchedFiles) {
-      await clearSceneAndBustCache(this.engineCommandManager)
-    } else if (this._switchedFiles) {
-      // Reset the switched files boolean.
-      this._switchedFiles = false
-    }
-  }
+  safeParse(code: string): Node<Program> | null {
+    const ast = parse(code)
+    this.lints = []
+    this.kclErrors = []
+    if (!err(ast)) return ast
+    const kclerror: KCLError = ast as KCLError
 
-  async safeParse(code: string): Promise<Node<Program> | null> {
-    const result = parse(code)
-    this.diagnostics = []
-    this._hasErrors = false
-
-    if (err(result)) {
-      const kclerror: KCLError = result as KCLError
-      this.diagnostics = kclErrorsToDiagnostics([kclerror])
-      this._hasErrors = true
-
-      await this.checkIfSwitchedFilesShouldClear()
-      return null
-    }
-
-    this.addDiagnostics(complilationErrorsToDiagnostics(result.errors))
-    this.addDiagnostics(complilationErrorsToDiagnostics(result.warnings))
-    if (result.errors.length > 0) {
-      this._hasErrors = true
-
-      await this.checkIfSwitchedFilesShouldClear()
-      return null
-    }
-
-    return result.program
+    this.addKclErrors([kclerror])
+    // TODO: re-eval if session should end?
+    if (kclerror.msg === 'file is empty')
+      this.engineCommandManager?.endSession()
+    return null
   }
 
   async ensureWasmInit() {
@@ -301,16 +267,19 @@ export class KclManager {
     this._cancelTokens.set(currentExecutionId, false)
 
     this.isExecuting = true
+    // Make sure we clear before starting again. End session will do this.
+    this.engineCommandManager?.endSession()
     await this.ensureWasmInit()
     const { logs, errors, execState, isInterrupted } = await executeAst({
       ast,
+      idGenerator: this.execState.idGenerator,
       engineCommandManager: this.engineCommandManager,
     })
 
     // Program was not interrupted, setup the scene
     // Do not send send scene commands if the program was interrupted, go to clean up
     if (!isInterrupted) {
-      this.addDiagnostics(await lintAst({ ast: ast }))
+      this.lints = await lintAst({ ast: ast })
 
       sceneInfra.modelingSend({ type: 'code edit during sketch' })
       setSelectionFilterToDefault(execState.memory, this.engineCommandManager)
@@ -352,7 +321,9 @@ export class KclManager {
 
     this.logs = logs
     // Do not add the errors since the program was interrupted and the error is not a real KCL error
-    this.addDiagnostics(isInterrupted ? [] : kclErrorsToDiagnostics(errors))
+    this.addKclErrors(isInterrupted ? [] : errors)
+    // Reset the next ID index so that we reuse the previous IDs next time.
+    execState.idGenerator.nextId = 0
     this.execState = execState
     if (!errors.length) {
       this.lastSuccessfulProgramMemory = execState.memory
@@ -384,7 +355,7 @@ export class KclManager {
       console.error(newCode)
       return
     }
-    const newAst = await this.safeParse(newCode)
+    const newAst = this.safeParse(newCode)
     if (!newAst) {
       this.clearAst()
       return
@@ -393,13 +364,13 @@ export class KclManager {
 
     const { logs, errors, execState } = await executeAst({
       ast: newAst,
+      idGenerator: this.execState.idGenerator,
       engineCommandManager: this.engineCommandManager,
-      // We make sure to send an empty program memory to denote we mean mock mode.
-      programMemoryOverride: ProgramMemory.empty(),
+      useFakeExecutor: true,
     })
 
     this._logs = logs
-    this.addDiagnostics(kclErrorsToDiagnostics(errors))
+    this._kclErrors = errors
     this._execState = execState
     this._programMemory = execState.memory
     if (!errors.length) {
@@ -427,7 +398,7 @@ export class KclManager {
           ...artifact,
           codeRef: {
             ...artifact.codeRef,
-            range: [node.start, node.end, true],
+            range: [node.start, node.end],
           },
         })
       }
@@ -439,7 +410,7 @@ export class KclManager {
     })
   }
   async executeCode(zoomToFit?: boolean): Promise<void> {
-    const ast = await this.safeParse(codeManager.code)
+    const ast = this.safeParse(codeManager.code)
     if (!ast) {
       this.clearAst()
       return
@@ -447,9 +418,9 @@ export class KclManager {
     this.ast = { ...ast }
     return this.executeAst({ zoomToFit })
   }
-  async format() {
+  format() {
     const originalCode = codeManager.code
-    const ast = await this.safeParse(originalCode)
+    const ast = this.safeParse(originalCode)
     if (!ast) {
       this.clearAst()
       return
@@ -489,7 +460,7 @@ export class KclManager {
     const newCode = recast(ast)
     if (err(newCode)) return Promise.reject(newCode)
 
-    const astWithUpdatedSource = await this.safeParse(newCode)
+    const astWithUpdatedSource = this.safeParse(newCode)
     if (!astWithUpdatedSource) return Promise.reject(new Error('bad ast'))
     let returnVal: Selections | undefined = undefined
 
@@ -519,7 +490,7 @@ export class KclManager {
         if (start && end) {
           returnVal.graphSelections.push({
             codeRef: {
-              range: [start, end, true],
+              range: [start, end],
               pathToNode: path,
             },
           })

src/lang/artifact.test.ts

@@ -1,4 +1,4 @@
-import { assertParse, initPromise } from './wasm'
+import { parse, initPromise } from './wasm'
 import { enginelessExecutor } from '../lib/testHelpers'
 
 beforeAll(async () => {
@@ -14,7 +14,7 @@ const mySketch001 = startSketchOn('XY')
   |> lineTo([-1.59, -1.54], %)
   |> lineTo([0.46, -5.82], %)
   // |> rx(45, %)`
-    const execState = await enginelessExecutor(assertParse(code))
+    const execState = await enginelessExecutor(parse(code))
     // @ts-ignore
     const sketch001 = execState.memory.get('mySketch001')
     expect(sketch001).toEqual({
@@ -67,7 +67,7 @@ const mySketch001 = startSketchOn('XY')
   |> lineTo([0.46, -5.82], %)
   // |> rx(45, %)
   |> extrude(2, %)`
-    const execState = await enginelessExecutor(assertParse(code))
+    const execState = await enginelessExecutor(parse(code))
     // @ts-ignore
     const sketch001 = execState.memory.get('mySketch001')
     expect(sketch001).toEqual({
@@ -147,7 +147,7 @@ const sk2 = startSketchOn('XY')
   |> extrude(2, %)
 
 `
-    const execState = await enginelessExecutor(assertParse(code))
+    const execState = await enginelessExecutor(parse(code))
     const programMemory = execState.memory
     // @ts-ignore
     const geos = [programMemory.get('theExtrude'), programMemory.get('sk2')]

src/lang/errors.test.ts

@@ -8,14 +8,20 @@ describe('test kclErrToDiagnostic', () => {
         message: '',
         kind: 'semantic',
         msg: 'Semantic error',
-        sourceRange: [0, 1, true],
+        sourceRanges: [
+          [0, 1, 0],
+          [2, 3, 0],
+        ],
       },
       {
         name: '',
         message: '',
         kind: 'type',
         msg: 'Type error',
-        sourceRange: [4, 5, true],
+        sourceRanges: [
+          [4, 5, 0],
+          [6, 7, 0],
+        ],
       },
     ]
     const diagnostics = kclErrorsToDiagnostics(errors)
@@ -26,12 +32,24 @@ describe('test kclErrToDiagnostic', () => {
         message: 'Semantic error',
         severity: 'error',
       },
+      {
+        from: 2,
+        to: 3,
+        message: 'Semantic error',
+        severity: 'error',
+      },
       {
         from: 4,
         to: 5,
         message: 'Type error',
         severity: 'error',
       },
+      {
+        from: 6,
+        to: 7,
+        message: 'Type error',
+        severity: 'error',
+      },
     ])
   })
 })

src/lang/errors.ts

@@ -1,90 +1,88 @@
 import { KclError as RustKclError } from '../wasm-lib/kcl/bindings/KclError'
-import { CompilationError } from 'wasm-lib/kcl/bindings/CompilationError'
 import { Diagnostic as CodeMirrorDiagnostic } from '@codemirror/lint'
 import { posToOffset } from '@kittycad/codemirror-lsp-client'
 import { Diagnostic as LspDiagnostic } from 'vscode-languageserver-protocol'
 import { Text } from '@codemirror/state'
-import { EditorView } from 'codemirror'
-import { SourceRange } from 'lang/wasm'
+
+const TOP_LEVEL_MODULE_ID = 0
 
 type ExtractKind<T> = T extends { kind: infer K } ? K : never
 export class KCLError extends Error {
   kind: ExtractKind<RustKclError> | 'name'
-  sourceRange: SourceRange
+  sourceRanges: [number, number, number][]
   msg: string
-
   constructor(
     kind: ExtractKind<RustKclError> | 'name',
     msg: string,
-    sourceRange: SourceRange
+    sourceRanges: [number, number, number][]
   ) {
     super()
     this.kind = kind
     this.msg = msg
-    this.sourceRange = sourceRange
+    this.sourceRanges = sourceRanges
     Object.setPrototypeOf(this, KCLError.prototype)
   }
 }
 
 export class KCLLexicalError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('lexical', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('lexical', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
 
 export class KCLInternalError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('internal', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('internal', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
 
 export class KCLSyntaxError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('syntax', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('syntax', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
 
 export class KCLSemanticError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('semantic', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('semantic', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLSemanticError.prototype)
   }
 }
 
 export class KCLTypeError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('type', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('type', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLTypeError.prototype)
   }
 }
 
 export class KCLUnimplementedError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('unimplemented', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('unimplemented', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLUnimplementedError.prototype)
   }
 }
 
 export class KCLUnexpectedError extends KCLError {
-  constructor(msg: string, sourceRange: SourceRange) {
-    super('unexpected', msg, sourceRange)
+  constructor(msg: string, sourceRanges: [number, number, number][]) {
+    super('unexpected', msg, sourceRanges)
     Object.setPrototypeOf(this, KCLUnexpectedError.prototype)
   }
 }
 
 export class KCLValueAlreadyDefined extends KCLError {
-  constructor(key: string, sourceRange: SourceRange) {
-    super('name', `Key ${key} was already defined elsewhere`, sourceRange)
+  constructor(key: string, sourceRanges: [number, number, number][]) {
+    super('name', `Key ${key} was already defined elsewhere`, sourceRanges)
     Object.setPrototypeOf(this, KCLValueAlreadyDefined.prototype)
   }
 }
 
 export class KCLUndefinedValueError extends KCLError {
-  constructor(key: string, sourceRange: SourceRange) {
-    super('name', `Key ${key} has not been defined`, sourceRange)
+  constructor(key: string, sourceRanges: [number, number, number][]) {
+    super('name', `Key ${key} has not been defined`, sourceRanges)
     Object.setPrototypeOf(this, KCLUndefinedValueError.prototype)
   }
 }
@@ -101,14 +99,27 @@ export function lspDiagnosticsToKclErrors(
     .flatMap(
       ({ range, message }) =>
         new KCLError('unexpected', message, [
-          posToOffset(doc, range.start)!,
-          posToOffset(doc, range.end)!,
-          true,
+          [
+            posToOffset(doc, range.start)!,
+            posToOffset(doc, range.end)!,
+            TOP_LEVEL_MODULE_ID,
+          ],
         ])
     )
+    .filter(({ sourceRanges }) => {
+      const [from, to, moduleId] = sourceRanges[0]
+      return (
+        from !== null &&
+        to !== null &&
+        from !== undefined &&
+        to !== undefined &&
+        // Filter out errors that are not from the top-level module.
+        moduleId === TOP_LEVEL_MODULE_ID
+      )
+    })
     .sort((a, b) => {
-      const c = a.sourceRange[0]
-      const d = b.sourceRange[0]
+      const c = a.sourceRanges[0][0]
+      const d = b.sourceRanges[0][0]
       switch (true) {
         case c < d:
           return -1
@@ -126,48 +137,17 @@ export function lspDiagnosticsToKclErrors(
 export function kclErrorsToDiagnostics(
   errors: KCLError[]
 ): CodeMirrorDiagnostic[] {
-  return errors
-    ?.filter((err) => err.sourceRange[2])
-    .map((err) => {
-      return {
-        from: err.sourceRange[0],
-        to: err.sourceRange[1],
-        message: err.msg,
-        severity: 'error',
-      }
-    })
-}
-
-export function complilationErrorsToDiagnostics(
-  errors: CompilationError[]
-): CodeMirrorDiagnostic[] {
-  return errors
-    ?.filter((err) => err.sourceRange[2] === 0)
-    .map((err) => {
-      let severity: any = 'error'
-      if (err.severity === 'Warning') {
-        severity = 'warning'
-      }
-      let actions
-      const suggestion = err.suggestion
-      if (suggestion) {
-        actions = [
-          {
-            name: suggestion.title,
-            apply: (view: EditorView, from: number, to: number) => {
-              view.dispatch({
-                changes: { from, to, insert: suggestion.insert },
-              })
-            },
-          },
-        ]
-      }
-      return {
-        from: err.sourceRange[0],
-        to: err.sourceRange[1],
-        message: err.message,
-        severity,
-        actions,
-      }
-    })
+  return errors?.flatMap((err) => {
+    const sourceRanges: CodeMirrorDiagnostic[] = err.sourceRanges
+      // Filter out errors that are not from the top-level module.
+      .filter(([_start, _end, moduleId]) => moduleId === TOP_LEVEL_MODULE_ID)
+      .map(([from, to]) => {
+        return { from, to, message: err.msg, severity: 'error' }
+      })
+    // Make sure we didn't filter out all the source ranges.
+    if (sourceRanges.length === 0) {
+      sourceRanges.push({ from: 0, to: 0, message: err.msg, severity: 'error' })
+    }
+    return sourceRanges
+  })
 }

src/lang/executor.test.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs'
 
 import {
-  assertParse,
+  parse,
   ProgramMemory,
   Sketch,
   initPromise,
@@ -472,7 +472,7 @@ describe('Testing Errors', () => {
 const theExtrude = startSketchOn('XY')
   |> startProfileAt([0, 0], %)
   |> line([-2.4, 5], %)
-  |> line(myVarZ, %)
+  |> line([-0.76], myVarZ, %)
   |> line([5,5], %)
   |> close(%)
   |> extrude(4, %)`
@@ -480,7 +480,7 @@ const theExtrude = startSketchOn('XY')
       new KCLError(
         'undefined_value',
         'memory item key `myVarZ` is not defined',
-        [129, 135, true]
+        [[129, 135, 0]]
       )
     )
   })
@@ -492,7 +492,7 @@ async function exe(
   code: string,
   programMemory: ProgramMemory = ProgramMemory.empty()
 ) {
-  const ast = assertParse(code)
+  const ast = parse(code)
 
   const execState = await enginelessExecutor(ast, programMemory)
   return execState.memory

src/lang/getNodePathFromSourceRange.test.ts

@@ -1,5 +1,5 @@
 import { getNodePathFromSourceRange, getNodeFromPath } from './queryAst'
-import { Identifier, assertParse, initPromise, Parameter } from './wasm'
+import { Identifier, parse, initPromise, Parameter } from './wasm'
 import { err } from 'lib/trap'
 
 beforeAll(async () => {
@@ -17,19 +17,19 @@ const sk3 = startSketchAt([0, 0])
 `
     const subStr = 'lineTo([3, 4], %, $yo)'
     const lineToSubstringIndex = code.indexOf(subStr)
-    const sourceRange: [number, number, boolean] = [
+    const sourceRange: [number, number] = [
       lineToSubstringIndex,
       lineToSubstringIndex + subStr.length,
-      true,
     ]
 
-    const ast = assertParse(code)
+    const ast = parse(code)
+    if (err(ast)) throw ast
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)
     const _node = getNodeFromPath<any>(ast, nodePath)
     if (err(_node)) throw _node
     const { node } = _node
 
-    expect([node.start, node.end, true]).toEqual(sourceRange)
+    expect([node.start, node.end]).toEqual(sourceRange)
     expect(node.type).toBe('CallExpression')
   })
   it('gets path right for function definition params', () => {
@@ -45,13 +45,13 @@ const sk3 = startSketchAt([0, 0])
 const b1 = cube([0,0], 10)`
     const subStr = 'pos, scale'
     const subStrIndex = code.indexOf(subStr)
-    const sourceRange: [number, number, boolean] = [
+    const sourceRange: [number, number] = [
       subStrIndex,
       subStrIndex + 'pos'.length,
-      true,
     ]
 
-    const ast = assertParse(code)
+    const ast = parse(code)
+    if (err(ast)) throw ast
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)
     const _node = getNodeFromPath<Parameter>(ast, nodePath)
     if (err(_node)) throw _node
@@ -60,7 +60,8 @@ const b1 = cube([0,0], 10)`
     expect(nodePath).toEqual([
       ['body', ''],
       [0, 'index'],
-      ['declaration', 'VariableDeclaration'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
       ['init', ''],
       ['params', 'FunctionExpression'],
       [0, 'index'],
@@ -81,13 +82,13 @@ const b1 = cube([0,0], 10)`
 const b1 = cube([0,0], 10)`
     const subStr = 'scale, 0'
     const subStrIndex = code.indexOf(subStr)
-    const sourceRange: [number, number, boolean] = [
+    const sourceRange: [number, number] = [
       subStrIndex,
       subStrIndex + 'scale'.length,
-      true,
     ]
 
-    const ast = assertParse(code)
+    const ast = parse(code)
+    if (err(ast)) throw ast
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)
     const _node = getNodeFromPath<Identifier>(ast, nodePath)
     if (err(_node)) throw _node
@@ -95,12 +96,14 @@ const b1 = cube([0,0], 10)`
     expect(nodePath).toEqual([
       ['body', ''],
       [0, 'index'],
-      ['declaration', 'VariableDeclaration'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
       ['init', ''],
       ['body', 'FunctionExpression'],
       ['body', 'FunctionExpression'],
       [0, 'index'],
-      ['declaration', 'VariableDeclaration'],
+      ['declarations', 'VariableDeclaration'],
+      [0, 'index'],
       ['init', ''],
       ['body', 'PipeExpression'],
       [2, 'index'],