Show toolbar tooltips on hover only, hide when dropdowns are open (#5109)

* Show toolbar tooltips on hover only, hide when dropdowns are open

* A snapshot a day keeps the bugs away! 📷🐛 (OS: namespace-profile-ubuntu-8-cores)

* Re-run CI

---------

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

.codespellrc

@@ -1,3 +1,3 @@
 [codespell]
-ignore-words-list: crate,everytime,inout,co-ordinate,ot,nwo,atleast,ue,afterall
+ignore-words-list: crate,everytime,inout,co-ordinate,ot,nwo,atleast,ue,afterall,ser
 skip: **/target,node_modules,build,dist,./out,**/Cargo.lock,./docs/kcl/*.md,.yarn.lock,**/yarn.lock,./openapi/*.json,./packages/codemirror-lang-kcl/test/all.test.ts,tsconfig.tsbuildinfo

.eslintrc

@@ -6,16 +6,24 @@
     "plugins": [
       "css-modules",
       "jest",
+      "jsx-a11y",
       "react",
+      "react-hooks",
       "suggest-no-throw",
+      "testing-library",
       "@typescript-eslint"
     ],
     "extends": [
-      "plugin:css-modules/recommended"
+      "plugin:css-modules/recommended",
+      "plugin:jsx-a11y/recommended",
+      "plugin:react-hooks/recommended"
     ],
     "rules": {
       "@typescript-eslint/no-floating-promises": "error",
       "@typescript-eslint/no-misused-promises": "error",
+      "jsx-a11y/click-events-have-key-events": "off",
+      "jsx-a11y/no-autofocus": "off",
+      "jsx-a11y/no-noninteractive-element-interactions": "off",
       "no-restricted-globals": [
         "error",
         {
@@ -33,6 +41,9 @@
     "overrides": [
       {
         "files": ["e2e/**/*.ts"], // Update the pattern based on your file structure
+        "extends": [
+          "plugin:testing-library/react"
+        ],
         "rules": {
           "suggest-no-throw/suggest-no-throw": "off",
           "testing-library/prefer-screen-queries": "off",
@@ -41,6 +52,9 @@
       },
       {
         "files": ["src/**/*.test.ts"],
+        "extends": [
+          "plugin:testing-library/react"
+        ],
         "rules": {
           "suggest-no-throw/suggest-no-throw": "off",
         }

.github/dependabot.yml

@@ -6,23 +6,29 @@
 version: 2
 updates:
   - package-ecosystem: 'npm' # See documentation for possible values
-    directory: '/' # Location of package manifests
+    directories:
+      - '/'
+      - '/packages/codemirror-lang-kcl/'
+      - '/packages/codemirror-lsp-client/'
     schedule:
-      interval: 'weekly'
+      interval: weekly
+      day: monday
     reviewers:
       - franknoirot
       - irev-dev
   - package-ecosystem: 'github-actions' # See documentation for possible values
     directory: '/' # Location of package manifests
     schedule:
-      interval: 'weekly'
+      interval: weekly
+      day: monday
     reviewers:
       - adamchalmers
       - jessfraz
   - package-ecosystem: 'cargo' # See documentation for possible values
     directory: '/src/wasm-lib/' # Location of package manifests
     schedule:
-      interval: 'weekly'
+      interval: weekly
+      day: monday
     reviewers:
       - adamchalmers
       - jessfraz
@@ -30,3 +36,6 @@ updates:
       serde-dependencies:
         patterns:
           - "serde*"
+      wasm-bindgen-deps:
+        patterns:
+          - "wasm-bindgen*"

.github/workflows/build-and-store-wasm.yml

@@ -27,7 +27,7 @@ jobs:
 
 
       # Upload the WASM bundle as an artifact
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: wasm-bundle
           path: src/wasm-lib/pkg

.github/workflows/build-apps.yml

@@ -126,7 +126,13 @@ jobs:
           node-version-file: '.nvmrc'
           cache: 'yarn' # Set this to npm, yarn or pnpm.
 
-      - run: yarn install
+      - name: yarn install
+        # Windows is picky sometimes and fails on fetch. Step takes about ~30s
+        uses: nick-fields/retry@v3.0.0
+        with:
+          timeout_minutes: 2
+          max_attempts: 3
+          command: yarn install
 
       - run: yarn tronb:vite
 

.github/workflows/cargo-bench.yml

@@ -1,44 +0,0 @@
-on:
-  push:
-    branches:
-      - main
-    paths:
-      - '**.rs'
-      - '**/Cargo.toml'
-      - '**/Cargo.lock'
-      - '**/rust-toolchain.toml'
-      - .github/workflows/cargo-bench.yml
-  pull_request:
-    paths:
-      - '**.rs'
-      - '**/Cargo.toml'
-      - '**/Cargo.lock'
-      - '**/rust-toolchain.toml'
-      - .github/workflows/cargo-bench.yml
-  workflow_dispatch:
-permissions: read-all
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-name: cargo bench
-jobs:
-  cargo-bench:
-    name: Benchmark with iai
-    runs-on: ubuntu-latest-8-cores
-    steps:
-      - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@stable
-      - name: Install dependencies
-        run: |
-          cargo install cargo-criterion
-          sudo apt update
-          sudo apt install -y valgrind
-      - name: Rust Cache
-        uses: Swatinem/rust-cache@v2.6.1
-      - name: Benchmark kcl library
-        shell: bash
-        run: |-
-          cd src/wasm-lib/kcl; cargo bench --all-features -- iai
-        env:
-          KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN}}
-

.github/workflows/codemirror-lang-kcl.yml

@@ -0,0 +1,32 @@
+name: CodeMirror Lang KCL
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  yarn-unit-test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version-file: '.nvmrc'
+          cache: 'yarn'
+
+      - run: yarn install
+        working-directory: packages/codemirror-lang-kcl
+
+      - run: yarn tsc
+        working-directory: packages/codemirror-lang-kcl
+
+      - name: run unit tests
+        run: yarn test
+        working-directory: packages/codemirror-lang-kcl

docs/kcl/KNOWN-ISSUES.md

@@ -24,5 +24,3 @@ once fixed in engine will just start working here with no language changes.
     chamfer cases work currently.
 
 - **Appearance**: Changing the appearance on a loft does not work.
-
-- **Helix**: Currently sweeping a helix does not work.

docs/kcl/index.md

@@ -53,7 +53,6 @@ layout: manual
 * [`hollow`](kcl/hollow)
 * [`import`](kcl/import)
 * [`inch`](kcl/inch)
-* [`int`](kcl/int)
 * [`lastSegX`](kcl/lastSegX)
 * [`lastSegY`](kcl/lastSegY)
 * [`legAngX`](kcl/legAngX)

docs/kcl/int.md

@@ -4,6 +4,8 @@ excerpt: "Convert a number to an integer."
 layout: manual
 ---
 
+**WARNING:** This function is deprecated.
+
 Convert a number to an integer.
 
 DEPRECATED use floor(), ceil(), or round().

docs/kcl/types/HelixData.md

@@ -19,7 +19,7 @@ Data for a helix.
 | `revolutions` |`number`| Number of revolutions. | No |
 | `angleStart` |`number`| Start angle (in degrees). | No |
 | `ccw` |`boolean`| Is the helix rotation counter clockwise? The default is `false`. | No |
-| `length` |`number`| Length of the helix. | No |
+| `length` |`number`| Length of the helix. This is not necessary if the helix is created around an edge. If not given the length of the edge is used. | No |
 | `radius` |`number`| Radius of the helix. | No |
 | `axis` |[`Axis3dOrEdgeReference`](/docs/kcl/types/Axis3dOrEdgeReference)| Axis to use as mirror. | No |
 

e2e/playwright/code-pane-and-errors.spec.ts

@@ -280,7 +280,7 @@ test(
 
       await expect(page.getByRole('link', { name: 'bracket' })).toBeVisible()
       await expect(page.getByText('router-template-slate')).toBeVisible()
-      await expect(page.getByText('New Project')).toBeVisible()
+      await expect(page.getByText('Create project')).toBeVisible()
     })
 
     await test.step('Opening the router-template project should load', async () => {

e2e/playwright/command-bar-tests.spec.ts

@@ -45,46 +45,6 @@ test.describe('Command bar tests', () => {
     )
   })
 
-  // TODO: fix this test after the electron migration
-  test.fixme('Fillet from command bar', async ({ page, homePage }) => {
-    await page.addInitScript(async () => {
-      localStorage.setItem(
-        'persistCode',
-        `sketch001 = startSketchOn('XY')
-    |> startProfileAt([-5, -5], %)
-    |> line([0, 10], %)
-    |> line([10, 0], %)
-    |> line([0, -10], %)
-    |> lineTo([profileStartX(%), profileStartY(%)], %)
-    |> close(%)
-  extrude001 = extrude(-10, sketch001)`
-      )
-    })
-
-    const u = await getUtils(page)
-    await page.setBodyDimensions({ width: 1000, height: 500 })
-    await homePage.goToModelingScene()
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    const selectSegment = () => page.getByText(`line([0, -10], %)`).click()
-
-    await selectSegment()
-    await page.waitForTimeout(100)
-    await page.getByRole('button', { name: 'Fillet' }).click()
-    await page.waitForTimeout(100)
-    await page.keyboard.press('Enter') // skip selection
-    await page.waitForTimeout(100)
-    await page.keyboard.press('Enter') // accept default radius
-    await page.waitForTimeout(100)
-    await page.keyboard.press('Enter') // submit
-    await page.waitForTimeout(100)
-    await expect(page.locator('.cm-activeLine')).toContainText(
-      `fillet({ radius = ${KCL_DEFAULT_LENGTH}, tags = [seg01] }, %)`
-    )
-  })
-
   test('Command bar can change a setting, and switch back and forth between arguments', async ({
     page,
     homePage,

e2e/playwright/fixtures/cmdBarFixture.ts

@@ -135,4 +135,20 @@ export class CmdBarFixture {
       await promptEditCommand.first().click()
     }
   }
+
+  get cmdSearchInput() {
+    return this.page.getByTestId('cmd-bar-search')
+  }
+
+  get argumentInput() {
+    return this.page.getByTestId('cmd-bar-arg-value')
+  }
+
+  get cmdOptions() {
+    return this.page.getByTestId('cmd-bar-option')
+  }
+
+  chooseCommand = async (commandName: string) => {
+    await this.cmdOptions.getByText(commandName).click()
+  }
 }

e2e/playwright/fixtures/fixtureSetup.ts

@@ -121,18 +121,23 @@ export class AuthenticatedTronApp {
 
 export const fixtures = {
   cmdBar: async ({ page }: { page: Page }, use: any) => {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
     await use(new CmdBarFixture(page))
   },
   editor: async ({ page }: { page: Page }, use: any) => {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
     await use(new EditorFixture(page))
   },
   toolbar: async ({ page }: { page: Page }, use: any) => {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
     await use(new ToolbarFixture(page))
   },
   scene: async ({ page }: { page: Page }, use: any) => {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
     await use(new SceneFixture(page))
   },
   homePage: async ({ page }: { page: Page }, use: any) => {
+    // eslint-disable-next-line react-hooks/rules-of-hooks
     await use(new HomePageFixture(page))
   },
 }

e2e/playwright/fixtures/homePageFixture.ts

@@ -103,7 +103,7 @@ export class HomePageFixture {
       .toEqual(expectedState)
   }
 
-  createAndGoToProject = async (projectTitle: string) => {
+  createAndGoToProject = async (projectTitle = 'project-$nnn') => {
     await expect(this.projectSection).not.toHaveText('Loading your Projects...')
     await this.projectButtonNew.click()
     await this.projectTextName.click()

e2e/playwright/fixtures/toolbarFixture.ts

@@ -15,6 +15,8 @@ export class ToolbarFixture {
   extrudeButton!: Locator
   loftButton!: Locator
   sweepButton!: Locator
+  filletButton!: Locator
+  chamferButton!: Locator
   shellButton!: Locator
   offsetPlaneButton!: Locator
   startSketchBtn!: Locator
@@ -42,6 +44,8 @@ export class ToolbarFixture {
     this.extrudeButton = page.getByTestId('extrude')
     this.loftButton = page.getByTestId('loft')
     this.sweepButton = page.getByTestId('sweep')
+    this.filletButton = page.getByTestId('fillet3d')
+    this.chamferButton = page.getByTestId('chamfer3d')
     this.shellButton = page.getByTestId('shell')
     this.offsetPlaneButton = page.getByTestId('plane-offset')
     this.startSketchBtn = page.getByTestId('sketch')
@@ -59,6 +63,10 @@ export class ToolbarFixture {
     this.exeIndicator = page.getByTestId('model-state-indicator-execution-done')
   }
 
+  get logoLink() {
+    return this.page.getByTestId('app-logo')
+  }
+
   startSketchPlaneSelection = async () =>
     doAndWaitForImageDiff(this.page, () => this.startSketchBtn.click(), 500)
 

e2e/playwright/point-click.spec.ts

@@ -829,12 +829,6 @@ loftPointAndClickCases.forEach(({ shouldPreselect }) => {
         })
         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 () => {
@@ -844,12 +838,6 @@ loftPointAndClickCases.forEach(({ shouldPreselect }) => {
       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()
       })
     }
 
@@ -1032,6 +1020,436 @@ sketch002 = startSketchOn('XZ')
   })
 })
 
+test(`Fillet point-and-click`, async ({
+  context,
+  page,
+  homePage,
+  scene,
+  editor,
+  toolbar,
+  cmdBar,
+}) => {
+  // Code samples
+  const initialCode = `sketch001 = startSketchOn('XY')
+  |> startProfileAt([-12, -6], %)
+  |> line([0, 12], %)
+  |> line([24, 0], %)
+  |> line([0, -12], %)
+  |> lineTo([profileStartX(%), profileStartY(%)], %)
+  |> close(%)
+extrude001 = extrude(-12, sketch001)
+`
+  const firstFilletDeclaration = 'fillet({ radius = 5, tags = [seg01] }, %)'
+  const secondFilletDeclaration =
+    'fillet({       radius = 5,       tags = [getOppositeEdge(seg01)]     }, %)'
+
+  // Locators
+  const firstEdgeLocation = { x: 600, y: 193 }
+  const secondEdgeLocation = { x: 600, y: 383 }
+  const bodyLocation = { x: 630, y: 290 }
+  const [clickOnFirstEdge] = scene.makeMouseHelpers(
+    firstEdgeLocation.x,
+    firstEdgeLocation.y
+  )
+  const [clickOnSecondEdge] = scene.makeMouseHelpers(
+    secondEdgeLocation.x,
+    secondEdgeLocation.y
+  )
+
+  // Colors
+  const edgeColorWhite: [number, number, number] = [248, 248, 248]
+  const edgeColorYellow: [number, number, number] = [251, 251, 40] // Mac:B=67 Ubuntu:B=12
+  const bodyColor: [number, number, number] = [155, 155, 155]
+  const filletColor: [number, number, number] = [127, 127, 127]
+  const backgroundColor: [number, number, number] = [30, 30, 30]
+  const lowTolerance = 20
+  const highTolerance = 40
+
+  // Setup
+  await test.step(`Initial test setup`, async () => {
+    await context.addInitScript((initialCode) => {
+      localStorage.setItem('persistCode', initialCode)
+    }, initialCode)
+    await page.setBodyDimensions({ width: 1000, height: 500 })
+    await homePage.goToModelingScene()
+
+    // verify modeling scene is loaded
+    await scene.expectPixelColor(
+      backgroundColor,
+      secondEdgeLocation,
+      lowTolerance
+    )
+
+    // wait for stream to load
+    await scene.expectPixelColor(bodyColor, bodyLocation, highTolerance)
+  })
+
+  // Test 1: Command bar flow with preselected edges
+  await test.step(`Select first edge`, async () => {
+    await scene.expectPixelColor(
+      edgeColorWhite,
+      firstEdgeLocation,
+      lowTolerance
+    )
+    await clickOnFirstEdge()
+    await scene.expectPixelColor(
+      edgeColorYellow,
+      firstEdgeLocation,
+      highTolerance // Ubuntu color mismatch can require high tolerance
+    )
+  })
+
+  await test.step(`Apply fillet to the preselected edge`, async () => {
+    await page.waitForTimeout(100)
+    await toolbar.filletButton.click()
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      highlightedHeaderArg: 'selection',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Radius: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      highlightedHeaderArg: 'radius',
+      currentArgKey: 'radius',
+      currentArgValue: '5',
+      headerArguments: {
+        Selection: '1 face',
+        Radius: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      headerArguments: {
+        Selection: '1 face',
+        Radius: '5',
+      },
+      stage: 'review',
+    })
+    await cmdBar.progressCmdBar()
+  })
+
+  await test.step(`Confirm code is added to the editor`, async () => {
+    await editor.expectEditor.toContain(firstFilletDeclaration)
+    await editor.expectState({
+      diagnostics: [],
+      activeLines: ['|>fillet({radius=5,tags=[seg01]},%)'],
+      highlightedCode: '',
+    })
+  })
+
+  await test.step(`Confirm scene has changed`, async () => {
+    await scene.expectPixelColor(filletColor, firstEdgeLocation, lowTolerance)
+  })
+
+  // Test 2: Command bar flow without preselected edges
+  await test.step(`Open fillet UI without selecting edges`, async () => {
+    await page.waitForTimeout(100)
+    await toolbar.filletButton.click()
+    await cmdBar.expectState({
+      stage: 'arguments',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Radius: '',
+      },
+      highlightedHeaderArg: 'selection',
+      commandName: 'Fillet',
+    })
+  })
+
+  await test.step(`Select second edge`, async () => {
+    await scene.expectPixelColor(
+      edgeColorWhite,
+      secondEdgeLocation,
+      lowTolerance
+    )
+    await clickOnSecondEdge()
+    await scene.expectPixelColor(
+      edgeColorYellow,
+      secondEdgeLocation,
+      highTolerance // Ubuntu color mismatch can require high tolerance
+    )
+  })
+
+  await test.step(`Apply fillet to the second edge`, async () => {
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      highlightedHeaderArg: 'selection',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Radius: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      highlightedHeaderArg: 'radius',
+      currentArgKey: 'radius',
+      currentArgValue: '5',
+      headerArguments: {
+        Selection: '1 sweepEdge',
+        Radius: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Fillet',
+      headerArguments: {
+        Selection: '1 sweepEdge',
+        Radius: '5',
+      },
+      stage: 'review',
+    })
+    await cmdBar.progressCmdBar()
+  })
+
+  await test.step(`Confirm code is added to the editor`, async () => {
+    await editor.expectEditor.toContain(secondFilletDeclaration)
+    await editor.expectState({
+      diagnostics: [],
+      activeLines: ['radius=5,'],
+      highlightedCode: '',
+    })
+  })
+
+  await test.step(`Confirm scene has changed`, async () => {
+    await scene.expectPixelColor(
+      backgroundColor,
+      secondEdgeLocation,
+      lowTolerance
+    )
+  })
+})
+
+test(`Chamfer point-and-click`, async ({
+  context,
+  page,
+  homePage,
+  scene,
+  editor,
+  toolbar,
+  cmdBar,
+}) => {
+  // Code samples
+  const initialCode = `sketch001 = startSketchOn('XY')
+  |> startProfileAt([-12, -6], %)
+  |> line([0, 12], %)
+  |> line([24, 0], %)
+  |> line([0, -12], %)
+  |> lineTo([profileStartX(%), profileStartY(%)], %)
+  |> close(%)
+extrude001 = extrude(-12, sketch001)
+`
+  const firstChamferDeclaration = 'chamfer({ length = 5, tags = [seg01] }, %)'
+  const secondChamferDeclaration =
+    'chamfer({       length = 5,       tags = [getOppositeEdge(seg01)]     }, %)'
+
+  // Locators
+  const firstEdgeLocation = { x: 600, y: 193 }
+  const secondEdgeLocation = { x: 600, y: 383 }
+  const bodyLocation = { x: 630, y: 290 }
+  const [clickOnFirstEdge] = scene.makeMouseHelpers(
+    firstEdgeLocation.x,
+    firstEdgeLocation.y
+  )
+  const [clickOnSecondEdge] = scene.makeMouseHelpers(
+    secondEdgeLocation.x,
+    secondEdgeLocation.y
+  )
+
+  // Colors
+  const edgeColorWhite: [number, number, number] = [248, 248, 248]
+  const edgeColorYellow: [number, number, number] = [251, 251, 40] // Mac:B=67 Ubuntu:B=12
+  const bodyColor: [number, number, number] = [155, 155, 155]
+  const chamferColor: [number, number, number] = [168, 168, 168]
+  const backgroundColor: [number, number, number] = [30, 30, 30]
+  const lowTolerance = 20
+  const highTolerance = 40
+
+  // Setup
+  await test.step(`Initial test setup`, async () => {
+    await context.addInitScript((initialCode) => {
+      localStorage.setItem('persistCode', initialCode)
+    }, initialCode)
+    await page.setBodyDimensions({ width: 1000, height: 500 })
+    await homePage.goToModelingScene()
+
+    // verify modeling scene is loaded
+    await scene.expectPixelColor(
+      backgroundColor,
+      secondEdgeLocation,
+      lowTolerance
+    )
+
+    // wait for stream to load
+    await scene.expectPixelColor(bodyColor, bodyLocation, highTolerance)
+  })
+
+  // Test 1: Command bar flow with preselected edges
+  await test.step(`Select first edge`, async () => {
+    await scene.expectPixelColor(
+      edgeColorWhite,
+      firstEdgeLocation,
+      lowTolerance
+    )
+    await clickOnFirstEdge()
+    await scene.expectPixelColor(
+      edgeColorYellow,
+      firstEdgeLocation,
+      highTolerance // Ubuntu color mismatch can require high tolerance
+    )
+  })
+
+  await test.step(`Apply chamfer to the preselected edge`, async () => {
+    await page.waitForTimeout(100)
+    await toolbar.chamferButton.click()
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      highlightedHeaderArg: 'selection',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Length: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      highlightedHeaderArg: 'length',
+      currentArgKey: 'length',
+      currentArgValue: '5',
+      headerArguments: {
+        Selection: '1 face',
+        Length: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      headerArguments: {
+        Selection: '1 face',
+        Length: '5',
+      },
+      stage: 'review',
+    })
+    await cmdBar.progressCmdBar()
+  })
+
+  await test.step(`Confirm code is added to the editor`, async () => {
+    await editor.expectEditor.toContain(firstChamferDeclaration)
+    await editor.expectState({
+      diagnostics: [],
+      activeLines: ['|>chamfer({length=5,tags=[seg01]},%)'],
+      highlightedCode: '',
+    })
+  })
+
+  await test.step(`Confirm scene has changed`, async () => {
+    await scene.expectPixelColor(chamferColor, firstEdgeLocation, lowTolerance)
+  })
+
+  // Test 2: Command bar flow without preselected edges
+  await test.step(`Open chamfer UI without selecting edges`, async () => {
+    await page.waitForTimeout(100)
+    await toolbar.chamferButton.click()
+    await cmdBar.expectState({
+      stage: 'arguments',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Length: '',
+      },
+      highlightedHeaderArg: 'selection',
+      commandName: 'Chamfer',
+    })
+  })
+
+  await test.step(`Select second edge`, async () => {
+    await scene.expectPixelColor(
+      edgeColorWhite,
+      secondEdgeLocation,
+      lowTolerance
+    )
+    await clickOnSecondEdge()
+    await scene.expectPixelColor(
+      edgeColorYellow,
+      secondEdgeLocation,
+      highTolerance // Ubuntu color mismatch can require high tolerance
+    )
+  })
+
+  await test.step(`Apply chamfer to the second edge`, async () => {
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      highlightedHeaderArg: 'selection',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Length: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      highlightedHeaderArg: 'length',
+      currentArgKey: 'length',
+      currentArgValue: '5',
+      headerArguments: {
+        Selection: '1 sweepEdge',
+        Length: '',
+      },
+      stage: 'arguments',
+    })
+    await cmdBar.progressCmdBar()
+    await cmdBar.expectState({
+      commandName: 'Chamfer',
+      headerArguments: {
+        Selection: '1 sweepEdge',
+        Length: '5',
+      },
+      stage: 'review',
+    })
+    await cmdBar.progressCmdBar()
+  })
+
+  await test.step(`Confirm code is added to the editor`, async () => {
+    await editor.expectEditor.toContain(secondChamferDeclaration)
+    await editor.expectState({
+      diagnostics: [],
+      activeLines: ['length=5,'],
+      highlightedCode: '',
+    })
+  })
+
+  await test.step(`Confirm scene has changed`, async () => {
+    await scene.expectPixelColor(
+      backgroundColor,
+      secondEdgeLocation,
+      lowTolerance
+    )
+  })
+})
+
 const shellPointAndClickCapCases = [
   { shouldPreselect: true },
   { shouldPreselect: false },
@@ -1085,6 +1503,7 @@ shellPointAndClickCapCases.forEach(({ shouldPreselect }) => {
         await clickOnCap()
         await page.waitForTimeout(500)
         await cmdBar.progressCmdBar()
+        await page.waitForTimeout(500)
         await cmdBar.progressCmdBar()
         await cmdBar.expectState({
           stage: 'review',
@@ -1105,6 +1524,7 @@ shellPointAndClickCapCases.forEach(({ shouldPreselect }) => {
       await test.step(`Go through the command bar flow with a preselected face (cap)`, async () => {
         await toolbar.shellButton.click()
         await cmdBar.progressCmdBar()
+        await page.waitForTimeout(500)
         await cmdBar.progressCmdBar()
         await cmdBar.expectState({
           stage: 'review',
@@ -1186,6 +1606,7 @@ extrude001 = extrude(40, sketch001)
     await page.waitForTimeout(500)
     await page.keyboard.up('Shift')
     await cmdBar.progressCmdBar()
+    await page.waitForTimeout(500)
     await cmdBar.progressCmdBar()
     await cmdBar.expectState({
       stage: 'review',
@@ -1309,3 +1730,61 @@ shellSketchOnFacesCases.forEach((initialCode, index) => {
     })
   })
 })
+
+test(`Shell dry-run validation rejects sweeps`, async ({
+  context,
+  page,
+  homePage,
+  scene,
+  editor,
+  toolbar,
+  cmdBar,
+}) => {
+  const initialCode = `sketch001 = startSketchOn('YZ')
+  |> circle({
+       center = [0, 0],
+       radius = 500
+     }, %)
+sketch002 = startSketchOn('XZ')
+  |> startProfileAt([0, 0], %)
+  |> xLine(-2000, %)
+sweep001 = sweep({ path = sketch002 }, sketch001)
+`
+  await context.addInitScript((initialCode) => {
+    localStorage.setItem('persistCode', initialCode)
+  }, initialCode)
+  await page.setBodyDimensions({ width: 1000, height: 500 })
+  await homePage.goToModelingScene()
+  await scene.waitForExecutionDone()
+
+  // One dumb hardcoded screen pixel value
+  const testPoint = { x: 500, y: 250 }
+  const [clickOnSweep] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
+
+  await test.step(`Confirm sweep exists`, async () => {
+    await toolbar.closePane('code')
+    await scene.expectPixelColor([231, 231, 231], testPoint, 15)
+  })
+
+  await test.step(`Go through the Shell flow and fail validation with a toast`, async () => {
+    await toolbar.shellButton.click()
+    await cmdBar.expectState({
+      stage: 'arguments',
+      currentArgKey: 'selection',
+      currentArgValue: '',
+      headerArguments: {
+        Selection: '',
+        Thickness: '',
+      },
+      highlightedHeaderArg: 'selection',
+      commandName: 'Shell',
+    })
+    await clickOnSweep()
+    await page.waitForTimeout(500)
+    await cmdBar.progressCmdBar()
+    await expect(
+      page.getByText('Unable to shell with the provided selection')
+    ).toBeVisible()
+    await page.waitForTimeout(1000)
+  })
+})

e2e/playwright/projects.spec.ts

@@ -172,7 +172,7 @@ test(
       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 expect(page.getByText('Create project')).toBeVisible()
     })
     await test.step('opening broken code project should clear the scene and show the error', async () => {
       // Go back home.
@@ -253,7 +253,7 @@ test(
       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 expect(page.getByText('Create project')).toBeVisible()
     })
     await test.step('opening empty code project should clear the scene', async () => {
       // Go back home.
@@ -985,6 +985,126 @@ test.describe(`Project management commands`, () => {
       })
     }
   )
+  test(`Create a new project with a colliding name`, async ({
+    context,
+    homePage,
+    toolbar,
+    cmdBar,
+  }) => {
+    const projectName = 'test-project'
+    await test.step(`Setup`, async () => {
+      await context.folderSetupFn(async (dir) => {
+        const projectDir = path.join(dir, projectName)
+        await Promise.all([fsp.mkdir(projectDir, { recursive: true })])
+        await Promise.all([
+          fsp.copyFile(
+            executorInputPath('router-template-slate.kcl'),
+            path.join(projectDir, 'main.kcl')
+          ),
+        ])
+      })
+      await homePage.expectState({
+        projectCards: [
+          {
+            title: projectName,
+            fileCount: 1,
+          },
+        ],
+        sortBy: 'last-modified-desc',
+      })
+    })
+
+    await test.step('Create a new project with the same name', async () => {
+      await cmdBar.openCmdBar()
+      await cmdBar.chooseCommand('create project')
+      await cmdBar.expectState({
+        stage: 'arguments',
+        commandName: 'Create project',
+        currentArgKey: 'name',
+        currentArgValue: '',
+        headerArguments: {
+          Name: '',
+        },
+        highlightedHeaderArg: 'name',
+      })
+      await cmdBar.argumentInput.fill(projectName)
+      await cmdBar.progressCmdBar()
+    })
+
+    await test.step(`Check the project was created with a non-colliding name`, async () => {
+      await toolbar.logoLink.click()
+      await homePage.expectState({
+        projectCards: [
+          {
+            title: projectName + '-1',
+            fileCount: 1,
+          },
+          {
+            title: projectName,
+            fileCount: 1,
+          },
+        ],
+        sortBy: 'last-modified-desc',
+      })
+    })
+
+    await test.step('Create another project with the same name', async () => {
+      await cmdBar.openCmdBar()
+      await cmdBar.chooseCommand('create project')
+      await cmdBar.expectState({
+        stage: 'arguments',
+        commandName: 'Create project',
+        currentArgKey: 'name',
+        currentArgValue: '',
+        headerArguments: {
+          Name: '',
+        },
+        highlightedHeaderArg: 'name',
+      })
+      await cmdBar.argumentInput.fill(projectName)
+      await cmdBar.progressCmdBar()
+    })
+
+    await test.step(`Check the second project was created with a non-colliding name`, async () => {
+      await toolbar.logoLink.click()
+      await homePage.expectState({
+        projectCards: [
+          {
+            title: projectName + '-2',
+            fileCount: 1,
+          },
+          {
+            title: projectName + '-1',
+            fileCount: 1,
+          },
+          {
+            title: projectName,
+            fileCount: 1,
+          },
+        ],
+        sortBy: 'last-modified-desc',
+      })
+    })
+  })
+})
+
+test(`Create a few projects using the default project name`, async ({
+  homePage,
+  toolbar,
+}) => {
+  for (let i = 0; i < 12; i++) {
+    await test.step(`Create project ${i}`, async () => {
+      await homePage.expectState({
+        projectCards: Array.from({ length: i }, (_, i) => ({
+          title: `project-${i.toString().padStart(3, '0')}`,
+          fileCount: 1,
+        })).toReversed(),
+        sortBy: 'last-modified-desc',
+      })
+      await homePage.createAndGoToProject()
+      await toolbar.logoLink.click()
+    })
+  }
 })
 
 test(
@@ -1391,7 +1511,7 @@ extrude001 = extrude(200, sketch001)`)
     await page.getByTestId('app-logo').click()
 
     await expect(
-      page.getByRole('button', { name: 'New project' })
+      page.getByRole('button', { name: 'Create project' })
     ).toBeVisible()
 
     for (let i = 1; i <= 10; i++) {
@@ -1465,7 +1585,7 @@ test(
 
       await expect(page.getByRole('link', { name: 'bracket' })).toBeVisible()
       await expect(page.getByText('router-template-slate')).toBeVisible()
-      await expect(page.getByText('New Project')).toBeVisible()
+      await expect(page.getByText('Create project')).toBeVisible()
     })
 
     await test.step('Opening the router-template project should load the stream', async () => {
@@ -1494,7 +1614,7 @@ test(
 
       await expect(page.getByRole('link', { name: 'bracket' })).toBeVisible()
       await expect(page.getByText('router-template-slate')).toBeVisible()
-      await expect(page.getByText('New Project')).toBeVisible()
+      await expect(page.getByText('Create project')).toBeVisible()
     })
   }
 )

e2e/playwright/test-utils.ts

@@ -1078,7 +1078,7 @@ export async function createProject({
   returnHome?: boolean
 }) {
   await test.step(`Create project and navigate to it`, async () => {
-    await page.getByRole('button', { name: 'New project' }).click()
+    await page.getByRole('button', { name: 'Create project' }).click()
     await page.getByRole('textbox', { name: 'Name' }).fill(name)
     await page.getByRole('button', { name: 'Continue' }).click()
 

e2e/playwright/testing-samples-loading.spec.ts

@@ -8,8 +8,8 @@ import { UnitLength_type } from '@kittycad/lib/dist/types/src/models'
 
 test.describe('Testing in-app sample loading', () => {
   /**
-   * Note this test implicitly depends on the KCL sample "car-wheel.kcl",
-   * its title, and its units settings. https://github.com/KittyCAD/kcl-samples/blob/main/car-wheel/car-wheel.kcl
+   * Note this test implicitly depends on the KCL sample "a-parametric-bearing-pillow-block",
+   * its title, and its units settings. https://github.com/KittyCAD/kcl-samples/blob/main/a-parametric-bearing-pillow-block/main.kcl
    */
   test('Web: should overwrite current code, cannot create new file', async ({
     editor,
@@ -29,8 +29,8 @@ test.describe('Testing in-app sample loading', () => {
 
     // Locators and constants
     const newSample = {
-      file: 'car-wheel' + FILE_EXT,
-      title: 'Car Wheel',
+      file: 'a-parametric-bearing-pillow-block' + FILE_EXT,
+      title: 'A Parametric Bearing Pillow Block',
     }
     const commandBarButton = page.getByRole('button', { name: 'Commands' })
     const samplesCommandOption = page.getByRole('option', {
@@ -75,8 +75,8 @@ test.describe('Testing in-app sample loading', () => {
 
   /**
    * Note this test implicitly depends on the KCL samples:
-   * "car-wheel.kcl": https://github.com/KittyCAD/kcl-samples/blob/main/car-wheel/car-wheel.kcl
-   * "gear-rack.kcl": https://github.com/KittyCAD/kcl-samples/blob/main/gear-rack/gear-rack.kcl
+   * "a-parametric-bearing-pillow-block": https://github.com/KittyCAD/kcl-samples/blob/main/a-parametric-bearing-pillow-block/main.kcl
+   * "gear-rack": https://github.com/KittyCAD/kcl-samples/blob/main/gear-rack/main.kcl
    */
   test(
     'Desktop: should create new file by default, optionally overwrite',
@@ -93,8 +93,8 @@ test.describe('Testing in-app sample loading', () => {
 
       // Locators and constants
       const sampleOne = {
-        file: 'car-wheel' + FILE_EXT,
-        title: 'Car Wheel',
+        file: 'a-parametric-bearing-pillow-block' + FILE_EXT,
+        title: 'A Parametric Bearing Pillow Block',
       }
       const sampleTwo = {
         file: 'gear-rack' + FILE_EXT,

e2e/playwright/testing-selections.spec.ts

@@ -906,53 +906,6 @@ test.describe('Testing selections', () => {
     ).not.toBeDisabled()
   })
 
-  test('Fillet button states test', async ({ page, homePage }) => {
-    const u = await getUtils(page)
-    await page.addInitScript(async () => {
-      localStorage.setItem(
-        'persistCode',
-        `sketch001 = startSketchOn('XZ')
-    |> startProfileAt([-5, -5], %)
-    |> line([0, 10], %)
-    |> line([10, 0], %)
-    |> line([0, -10], %)
-    |> lineTo([profileStartX(%), profileStartY(%)], %)
-    |> close(%)`
-      )
-    })
-
-    await page.setBodyDimensions({ width: 1000, height: 500 })
-    await homePage.goToModelingScene()
-    await u.openDebugPanel()
-    await u.expectCmdLog('[data-message-type="execution-done"]')
-    await u.closeDebugPanel()
-
-    const selectSegment = () => page.getByText(`line([10, 0], %)`).click()
-    const selectClose = () => page.getByText(`close(%)`).click()
-    const clickEmpty = () => page.mouse.click(950, 100)
-
-    // Now that we don't disable toolbar buttons based on selection,
-    // but rather based on a "selection" step in the command palette,
-    // the fillet button should always be enabled with a good network connection.
-    // I'm not sure if this test is actually useful anymore.
-    await selectSegment()
-    await expect(page.getByRole('button', { name: 'Fillet' })).toBeEnabled()
-    await clickEmpty()
-    await expect(page.getByRole('button', { name: 'Fillet' })).toBeEnabled()
-
-    // test fillet button with the body in the scene
-    const codeToAdd = `${await u.codeLocator.allInnerTexts()}
-  extrude001 = extrude(10, sketch001)`
-    await u.codeLocator.clear()
-    await u.codeLocator.fill(codeToAdd)
-    await selectSegment()
-    await expect(page.getByRole('button', { name: 'Fillet' })).toBeEnabled()
-    await selectClose()
-    await expect(page.getByRole('button', { name: 'Fillet' })).toBeEnabled()
-    await clickEmpty()
-    await expect(page.getByRole('button', { name: 'Fillet' })).toBeEnabled()
-  })
-
   const removeAfterFirstParenthesis = (inputString: string) => {
     const index = inputString.indexOf('(')
     if (index !== -1) {

package.json

@@ -65,7 +65,7 @@
     "vscode-languageserver-protocol": "^3.17.5",
     "vscode-uri": "^3.0.8",
     "web-vitals": "^3.5.2",
-    "xstate": "^5.17.4",
+    "xstate": "^5.19.2",
     "yargs": "^17.7.2"
   },
   "scripts": {
@@ -91,8 +91,8 @@
     "build:wasm": "yarn wasm-prep && cd src/wasm-lib && wasm-pack build --release --target web --out-dir pkg && cargo test -p kcl-lib export_bindings && cd ../.. && yarn isomorphic-copy-wasm && yarn fmt",
     "remove-importmeta": "sed -i 's/import.meta.url/window.location.origin/g' \"./src/wasm-lib/pkg/wasm_lib.js\"; sed -i '' 's/import.meta.url/window.location.origin/g' \"./src/wasm-lib/pkg/wasm_lib.js\" || echo \"sed for both mac and linux\"",
     "wasm-prep": "rimraf src/wasm-lib/pkg && mkdirp src/wasm-lib/pkg && rimraf src/wasm-lib/kcl/bindings",
-    "lint-fix": "eslint --fix src/**/*.ts src/**/*.tsx e2e/**/*.ts packages/codemirror-lsp-client/src/**/*.ts",
-    "lint": "eslint --max-warnings 0 src/**/*.ts src/**/*.tsx e2e/**/*.ts packages/codemirror-lsp-client/src/**/*.ts",
+    "lint-fix": "eslint --fix --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src",
+    "lint": "eslint --max-warnings 0 --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src",
     "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",
@@ -149,12 +149,11 @@
     "@electron-forge/plugin-vite": "7.4.0",
     "@electron/fuses": "1.8.0",
     "@iarna/toml": "^2.2.5",
-    "@lezer/generator": "^1.7.1",
+    "@lezer/generator": "^1.7.2",
     "@nabla/vite-plugin-eslint": "^2.0.5",
     "@playwright/test": "^1.49.0",
     "@testing-library/jest-dom": "^5.14.1",
     "@testing-library/react": "^15.0.2",
-    "@types/d3-force": "^3.0.10",
     "@types/diff": "^6.0.0",
     "@types/electron": "^1.6.10",
     "@types/isomorphic-fetch": "^0.0.39",
@@ -175,7 +174,6 @@
     "@vitest/web-worker": "^1.5.0",
     "@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",
@@ -183,8 +181,11 @@
     "eslint-plugin-css-modules": "^2.12.0",
     "eslint-plugin-import": "^2.30.0",
     "eslint-plugin-jest": "^28.10.0",
+    "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-react": "^7.37.3",
+    "eslint-plugin-react-hooks": "^5.1.0",
     "eslint-plugin-suggest-no-throw": "^1.0.0",
+    "eslint-plugin-testing-library": "^7.1.1",
     "happy-dom": "^16.3.0",
     "http-server": "^14.1.1",
     "husky": "^9.1.5",
@@ -198,7 +199,7 @@
     "setimmediate": "^1.0.5",
     "tailwindcss": "^3.4.1",
     "ts-node": "^10.0.0",
-    "typescript": "^5.7.2",
+    "typescript": "^5.7.3",
     "typescript-eslint": "^8.19.1",
     "vite": "^5.4.6",
     "vite-plugin-package-version": "^1.1.0",

packages/codemirror-lang-kcl/.gitignore

@@ -4,4 +4,5 @@ dist
 tsconfig.tsbuildinfo
 *.d.ts
 *.js
+!postcss.config.js
 !rollup.config.js

packages/codemirror-lang-kcl/package.json

@@ -28,6 +28,7 @@
     "@rollup/plugin-typescript": "^12.1.2",
     "rollup": "^4.29.1",
     "rollup-plugin-dts": "^6.1.1",
+    "vite-tsconfig-paths": "^4.3.2",
     "vitest": "^2.1.8"
   },
   "files": [

packages/codemirror-lang-kcl/postcss.config.js

@@ -0,0 +1 @@
+// This is here to prevent using the one in the root of the project.

packages/codemirror-lang-kcl/yarn.lock

@@ -398,7 +398,7 @@ check-error@^2.1.1:
   resolved "https://registry.yarnpkg.com/check-error/-/check-error-2.1.1.tgz#87eb876ae71ee388fa0471fe423f494be1d96ccc"
   integrity sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==
 
-debug@^4.3.7:
+debug@^4.1.1, debug@^4.3.7:
   version "4.4.0"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.4.0.tgz#2b3f2aea2ffeb776477460267377dc8710faba8a"
   integrity sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==
@@ -471,6 +471,11 @@ function-bind@^1.1.2:
   resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.2.tgz#2c02d864d97f3ea6c8830c464cbd11ab6eab7a1c"
   integrity sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==
 
+globrex@^0.1.2:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/globrex/-/globrex-0.1.2.tgz#dd5d9ec826232730cd6793a5e33a9302985e6098"
+  integrity sha512-uHJgbwAMwNFf5mLst7IWLNg14x1CkeqglJb/K3doi4dw6q2IvAAmM/Y81kevy83wP+Sst+nutFTYOGg3d1lsxg==
+
 hasown@^2.0.2:
   version "2.0.2"
   resolved "https://registry.yarnpkg.com/hasown/-/hasown-2.0.2.tgz#003eaf91be7adc372e84ec59dc37252cedb80003"
@@ -647,6 +652,11 @@ tinyspy@^3.0.2:
   resolved "https://registry.yarnpkg.com/tinyspy/-/tinyspy-3.0.2.tgz#86dd3cf3d737b15adcf17d7887c84a75201df20a"
   integrity sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==
 
+tsconfck@^3.0.3:
+  version "3.1.4"
+  resolved "https://registry.yarnpkg.com/tsconfck/-/tsconfck-3.1.4.tgz#de01a15334962e2feb526824339b51be26712229"
+  integrity sha512-kdqWFGVJqe+KGYvlSO9NIaWn9jT1Ny4oKVzAJsKii5eoE9snzTJzL4+MMVOMn+fikWGFmKEylcXL710V/kIPJQ==
+
 typescript@^5.7.2:
   version "5.7.2"
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.2.tgz#3169cf8c4c8a828cde53ba9ecb3d2b1d5dd67be6"
@@ -663,6 +673,15 @@ vite-node@2.1.8:
     pathe "^1.1.2"
     vite "^5.0.0"
 
+vite-tsconfig-paths@^4.3.2:
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/vite-tsconfig-paths/-/vite-tsconfig-paths-4.3.2.tgz#321f02e4b736a90ff62f9086467faf4e2da857a9"
+  integrity sha512-0Vd/a6po6Q+86rPlntHye7F31zA2URZMbH8M3saAZ/xR9QoGN/L21bxEGfXdWmFdNkqPpRdxFT7nmNe12e9/uA==
+  dependencies:
+    debug "^4.1.1"
+    globrex "^0.1.2"
+    tsconfck "^3.0.3"
+
 vite@^5.0.0:
   version "5.4.11"
   resolved "https://registry.yarnpkg.com/vite/-/vite-5.4.11.tgz#3b415cd4aed781a356c1de5a9ebafb837715f6e5"

packages/codemirror-lsp-client/package.json

@@ -29,7 +29,7 @@
     "vscode-uri": "^3.0.8"
   },
   "devDependencies": {
-    "@types/node": "^20.14.9",
+    "@types/node": "^22.10.6",
     "ts-node": "^10.9.2"
   }
 }

packages/codemirror-lsp-client/yarn.lock

@@ -109,12 +109,12 @@
   resolved "https://registry.yarnpkg.com/@tsconfig/node16/-/node16-1.0.4.tgz#0b92dcc0cc1c81f6f306a381f28e31b1a56536e9"
   integrity sha512-vxhUy4J8lyeyinH7Azl1pdd43GJhZH/tP2weN8TntQblOY+A0XbT8DJk1/oCPuOOyg/Ja757rG0CgHcWC8OfMA==
 
-"@types/node@^20.14.9":
-  version "20.14.9"
-  resolved "https://registry.yarnpkg.com/@types/node/-/node-20.14.9.tgz#12e8e765ab27f8c421a1820c99f5f313a933b420"
-  integrity sha512-06OCtnTXtWOZBJlRApleWndH4JsRVs1pDCc8dLSQp+7PpUpX3ePdHyeNSFTeSe7FtKyQkrlPvHwJOW3SLd8Oyg==
+"@types/node@^22.10.6":
+  version "22.10.6"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-22.10.6.tgz#5c6795e71635876039f853cbccd59f523d9e4239"
+  integrity sha512-qNiuwC4ZDAUNcY47xgaSuS92cjf8JbSUoaKS77bmLG1rU7MlATVSiw/IlrjtIyyskXBZ8KkNfjK/P5na7rgXbQ==
   dependencies:
-    undici-types "~5.26.4"
+    undici-types "~6.20.0"
 
 acorn-walk@^8.1.1:
   version "8.3.3"
@@ -187,10 +187,10 @@ typescript@^5.7.2:
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.2.tgz#3169cf8c4c8a828cde53ba9ecb3d2b1d5dd67be6"
   integrity sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==
 
-undici-types@~5.26.4:
-  version "5.26.5"
-  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-5.26.5.tgz#bcd539893d00b56e964fd2657a4866b221a65617"
-  integrity sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==
+undici-types@~6.20.0:
+  version "6.20.0"
+  resolved "https://registry.yarnpkg.com/undici-types/-/undici-types-6.20.0.tgz#8171bf22c1f588d1554d55bf204bc624af388433"
+  integrity sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg==
 
 v8-compile-cache-lib@^3.0.1:
   version "3.0.1"

public/kcl-samples-manifest-fallback.json

@@ -1,172 +1,212 @@
 [
   {
-    "file": "80-20-rail.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "80-20-rail/main.kcl",
+    "multipleFiles": false,
     "title": "80/20 Rail",
     "description": "An 80/20 extruded aluminum linear rail. T-slot profile adjustable by profile height, rail length, and origin position"
   },
   {
-    "file": "a-parametric-bearing-pillow-block.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "a-parametric-bearing-pillow-block/main.kcl",
+    "multipleFiles": false,
     "title": "A Parametric Bearing Pillow Block",
     "description": "A bearing pillow block, also known as a plummer block or pillow block bearing, is a pedestal used to provide support for a rotating shaft with the help of compatible bearings and various accessories. Housing a bearing, the pillow block provides a secure and stable foundation that allows the shaft to rotate smoothly within its machinery setup. These components are essential in a wide range of mechanical systems and machinery, playing a key role in reducing friction and supporting radial and axial loads."
   },
   {
-    "file": "ball-bearing.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "ball-bearing/main.kcl",
+    "multipleFiles": false,
     "title": "Ball Bearing",
     "description": "A ball bearing is a type of rolling-element bearing that uses balls to maintain the separation between the bearing races. The primary purpose of a ball bearing is to reduce rotational friction and support radial and axial loads."
   },
   {
-    "file": "bracket.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "bracket/main.kcl",
+    "multipleFiles": false,
     "title": "Shelf Bracket",
     "description": "This is a bracket that holds a shelf. It is made of aluminum and is designed to hold a force of 300 lbs. The bracket is 6 inches wide and the force is applied at the end of the shelf, 12 inches from the wall. The bracket has a factor of safety of 1.2. The legs of the bracket are 5 inches and 2 inches long. The thickness of the bracket is calculated from the constraints provided."
   },
   {
-    "file": "brake-caliper.kcl",
-    "title": "Brake Caliper",
-    "description": "Brake calipers are used to squeeze the brake pads against the rotor, causing larger and larger amounts of friction depending on how hard the brakes are pressed."
-  },
-  {
-    "file": "car-wheel.kcl",
-    "title": "Car Wheel",
-    "description": "A sports car wheel with a circular lug pattern and spokes."
-  },
-  {
-    "file": "car-wheel-assembly.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "car-wheel-assembly/main.kcl",
+    "multipleFiles": true,
     "title": "Car Wheel Assembly",
     "description": "A car wheel assembly with a rotor, tire, and lug nuts."
   },
   {
-    "file": "dodecahedron.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "dodecahedron/main.kcl",
+    "multipleFiles": false,
     "title": "Hollow Dodecahedron",
     "description": "A regular dodecahedron or pentagonal dodecahedron is a dodecahedron composed of regular pentagonal faces, three meeting at each vertex. This example shows constructing the individual faces of the dodecahedron and extruding inwards."
   },
   {
-    "file": "enclosure.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "enclosure/main.kcl",
+    "multipleFiles": false,
     "title": "Enclosure",
     "description": "An enclosure body and sealing lid for storing items"
   },
   {
-    "file": "flange-with-patterns.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "flange-with-patterns/main.kcl",
+    "multipleFiles": false,
     "title": "Flange",
     "description": "A flange is a flat rim, collar, or rib, typically forged or cast, that is used to strengthen an object, guide it, or attach it to another object. Flanges are known for their use in various applications, including piping, plumbing, and mechanical engineering, among others."
   },
   {
-    "file": "flange-xy.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "flange-xy/main.kcl",
+    "multipleFiles": false,
     "title": "Flange with XY coordinates",
     "description": "A flange is a flat rim, collar, or rib, typically forged or cast, that is used to strengthen an object, guide it, or attach it to another object. Flanges are known for their use in various applications, including piping, plumbing, and mechanical engineering, among others."
   },
   {
-    "file": "focusrite-scarlett-mounting-bracket.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "focusrite-scarlett-mounting-bracket/main.kcl",
+    "multipleFiles": false,
     "title": "A mounting bracket for the Focusrite Scarlett Solo audio interface",
     "description": "This is a bracket that holds an audio device underneath a desk or shelf. The audio device has dimensions of 144mm wide, 80mm length and 45mm depth with fillets of 6mm. This mounting bracket is designed to be 3D printed with PLA material"
   },
   {
-    "file": "food-service-spatula.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "food-service-spatula/main.kcl",
+    "multipleFiles": false,
     "title": "Food Service Spatula",
     "description": "Use these spatulas for mixing, flipping, and scraping."
   },
   {
-    "file": "french-press.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "french-press/main.kcl",
+    "multipleFiles": false,
     "title": "French Press",
     "description": "A french press immersion coffee maker"
   },
   {
-    "file": "gear.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "gear/main.kcl",
+    "multipleFiles": false,
     "title": "Spur Gear",
     "description": "A rotating machine part having cut teeth or, in the case of a cogwheel, inserted teeth (called cogs), which mesh with another toothed part to transmit torque. Geared devices can change the speed, torque, and direction of a power source. The two elements that define a gear are its circular shape and the teeth that are integrated into its outer edge, which are designed to fit into the teeth of another gear."
   },
   {
-    "file": "gear-rack.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "gear-rack/main.kcl",
+    "multipleFiles": false,
     "title": "100mm Gear Rack",
     "description": "A flat bar or rail that is engraved with teeth along its length. These teeth are designed to mesh with the teeth of a gear, known as a pinion. When the pinion, a small cylindrical gear, rotates, its teeth engage with the teeth on the rack, causing the rack to move linearly. Conversely, linear motion applied to the rack will cause the pinion to rotate."
   },
   {
-    "file": "hex-nut.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "hex-nut/main.kcl",
+    "multipleFiles": false,
     "title": "Hex nut",
     "description": "A hex nut is a type of fastener with a threaded hole and a hexagonal outer shape, used in a wide variety of applications to secure parts together. The hexagonal shape allows for a greater torque to be applied with wrenches or tools, making it one of the most common nut types in hardware."
   },
   {
-    "file": "i-beam.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "i-beam/main.kcl",
+    "multipleFiles": false,
     "title": "I-beam",
     "description": "A structural metal beam with an I shaped cross section. Often used in construction"
   },
   {
-    "file": "kitt.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "kitt/main.kcl",
+    "multipleFiles": false,
     "title": "Kitt",
     "description": "The beloved KittyCAD mascot in a voxelized style."
   },
   {
-    "file": "lego.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "lego/main.kcl",
+    "multipleFiles": false,
     "title": "Lego Brick",
     "description": "A standard Lego brick. This is a small, plastic construction block toy that can be interlocked with other blocks to build various structures, models, and figures. There are a lot of hacks used in this code."
   },
   {
-    "file": "lug-nut.kcl",
-    "title": "Lug Nut",
-    "description": "lug Nuts are essential components used to create secure connections, whether for electrical purposes, like terminating wires or grounding, or for mechanical purposes, such as providing mounting points or reinforcing structural joints."
-  },
-  {
-    "file": "mounting-plate.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "mounting-plate/main.kcl",
+    "multipleFiles": false,
     "title": "Mounting Plate",
     "description": "A flat piece of material, often metal or plastic, that serves as a support or base for attaching, securing, or mounting various types of equipment, devices, or components."
   },
   {
-    "file": "multi-axis-robot.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "multi-axis-robot/main.kcl",
+    "multipleFiles": true,
     "title": "Robot Arm",
     "description": "A 4 axis robotic arm for industrial use. These machines can be used for assembly, packaging, organization of goods, and quality inspection processes"
   },
   {
-    "file": "pipe.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "pipe/main.kcl",
+    "multipleFiles": false,
     "title": "Pipe",
     "description": "A tubular section or hollow cylinder, usually but not necessarily of circular cross-section, used mainly to convey substances that can flow."
   },
   {
-    "file": "pipe-flange-assembly.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "pipe-flange-assembly/main.kcl",
+    "multipleFiles": false,
     "title": "Pipe and Flange Assembly",
     "description": "A crucial component in various piping systems, designed to facilitate the connection, disconnection, and access to piping for inspection, cleaning, and modifications. This assembly combines pipes (long cylindrical conduits) with flanges (plate-like fittings) to create a secure yet detachable joint."
   },
   {
-    "file": "pipe-with-bend.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "pipe-with-bend/main.kcl",
+    "multipleFiles": false,
     "title": "Pipe with bend",
     "description": "A tubular section or hollow cylinder, usually but not necessarily of circular cross-section, used mainly to convey substances that can flow."
   },
   {
-    "file": "poopy-shoe.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "poopy-shoe/main.kcl",
+    "multipleFiles": false,
     "title": "Poopy Shoe",
     "description": "poop shute for bambu labs printer - optimized for printing."
   },
   {
-    "file": "router-template-cross-bar.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "router-template-cross-bar/main.kcl",
+    "multipleFiles": false,
     "title": "Router template for a cross bar",
     "description": "A guide for routing a notch into a cross bar."
   },
   {
-    "file": "router-template-slate.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "router-template-slate/main.kcl",
+    "multipleFiles": false,
     "title": "Router template for a slate",
     "description": "A guide for routing a slate for a cross bar."
   },
   {
-    "file": "sheet-metal-bracket.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "sheet-metal-bracket/main.kcl",
+    "multipleFiles": false,
     "title": "Sheet Metal Bracket",
     "description": "A component typically made from flat sheet metal through various manufacturing processes such as bending, punching, cutting, and forming. These brackets are used to support, attach, or mount other hardware components, often providing a structural or functional base for assembly."
   },
   {
-    "file": "socket-head-cap-screw.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "socket-head-cap-screw/main.kcl",
+    "multipleFiles": false,
     "title": "Socket Head Cap Screw",
     "description": "This is for a #10-24 screw that is 1.00 inches long. A socket head cap screw is a type of fastener that is widely used in a variety of applications requiring a high strength fastening solution. It is characterized by its cylindrical head and internal hexagonal drive, which allows for tightening with an Allen wrench or hex key."
   },
   {
-    "file": "tire.kcl",
-    "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": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "walkie-talkie/main.kcl",
+    "multipleFiles": true,
+    "title": "Walkie Talkie",
+    "description": "A portable, handheld two-way radio device that allows users to communicate wirelessly over short to medium distances. It operates on specific radio frequencies and features a push-to-talk button for transmitting messages, making it ideal for quick and reliable communication in outdoor, work, or emergency settings."
   },
   {
-    "file": "washer.kcl",
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "washer/main.kcl",
+    "multipleFiles": false,
     "title": "Washer",
     "description": "A small, typically disk-shaped component with a hole in the middle, used in a wide range of applications, primarily in conjunction with fasteners like bolts and screws. Washers distribute the load of a fastener across a broader area. This is especially important when the fastening surface is soft or uneven, as it helps to prevent damage to the surface and ensures the load is evenly distributed, reducing the risk of the fastener becoming loose over time."
-  },
-  {
-    "file": "wheel-rotor.kcl",
-    "title": "Wheel rotor",
-    "description": "A component of a disc brake system. It provides a surface for brake pads to press against, generating the friction needed to slow or stop the vehicle."
   }
 ]

src/Toolbar.tsx

@@ -210,6 +210,7 @@ export function Toolbar({
                 <ToolbarItemTooltip
                   itemConfig={maybeIconConfig[0]}
                   configCallbackProps={configCallbackProps}
+                  className="ui-open:!hidden"
                 />
               </ActionButtonDropdown>
             )
@@ -277,9 +278,11 @@ export function Toolbar({
 const ToolbarItemTooltip = memo(function ToolbarItemContents({
   itemConfig,
   configCallbackProps,
+  className,
 }: {
   itemConfig: ToolbarItemResolved
   configCallbackProps: ToolbarItemCallbackProps
+  className?: string
 }) {
   const { state } = useModelingContext()
 
@@ -305,8 +308,9 @@ const ToolbarItemTooltip = memo(function ToolbarItemContents({
           ? ({ '-webkit-app-region': 'no-drag' } as React.CSSProperties)
           : {}
       }
+      hoverOnly
       position="bottom"
-      wrapperClassName="!p-4 !pointer-events-auto"
+      wrapperClassName={'!p-4 !pointer-events-auto ' + className}
       contentClassName="!text-left text-wrap !text-xs !p-0 !pb-2 flex gap-2 !max-w-none !w-72 flex-col items-stretch"
     >
       <div className="rounded-top flex items-center gap-2 pt-3 pb-2 px-2 bg-chalkboard-20/50 dark:bg-chalkboard-80/50">

src/clientSideScene/CameraControls.ts

@@ -108,6 +108,8 @@ export class CameraControls {
   interactionGuards: MouseGuard = cameraMouseDragGuards.Zoo
   isFovAnimationInProgress = false
   perspectiveFovBeforeOrtho = 45
+  // NOTE: Duplicated state across Provider and singleton. Mapped from settingsMachine
+  _setting_allowOrbitInSketchMode = false
   get isPerspective() {
     return this.camera instanceof PerspectiveCamera
   }

src/clientSideScene/ClientSideSceneComp.tsx

@@ -25,13 +25,13 @@ import {
   CallExpression,
   PathToNode,
   Program,
-  SourceRange,
   Expr,
   parse,
   recast,
   defaultSourceRange,
   resultIsOk,
   ProgramMemory,
+  topLevelRange,
 } from 'lang/wasm'
 import { CustomIcon, CustomIconName } from 'components/CustomIcon'
 import { ConstrainInfo } from 'lang/std/stdTypes'
@@ -600,8 +600,8 @@ const ConstraintSymbol = ({
   if (err(_node)) return
   const node = _node.node
 
-  const range: SourceRange = node
-    ? [node.start, node.end, true]
+  const range = node
+    ? topLevelRange(node.start, node.end)
     : defaultSourceRange()
 
   if (_type === 'intersectionTag') return null

src/clientSideScene/sceneEntities.ts

@@ -1,5 +1,6 @@
 import {
   BoxGeometry,
+  Color,
   DoubleSide,
   Group,
   Intersection,
@@ -58,7 +59,9 @@ import {
   sourceRangeFromRust,
   resultIsOk,
   SourceRange,
+  topLevelRange,
 } from 'lang/wasm'
+import { calculate_circle_from_3_points } from '../wasm-lib/pkg/wasm_lib'
 import {
   engineCommandManager,
   kclManager,
@@ -70,7 +73,7 @@ import { getNodeFromPath, getNodePathFromSourceRange } from 'lang/queryAst'
 import { executeAst, ToolTip } from 'lang/langHelpers'
 import {
   createProfileStartHandle,
-  createArcGeometry,
+  createCircleGeometry,
   SegmentUtils,
   segmentUtils,
 } from './segments'
@@ -109,6 +112,8 @@ import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer'
 import { Point3d } from 'wasm-lib/kcl/bindings/Point3d'
 import { SegmentInputs } from 'lang/std/stdTypes'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
+import { LabeledArg } from 'wasm-lib/kcl/bindings/LabeledArg'
+import { Literal } from 'wasm-lib/kcl/bindings/Literal'
 import { radToDeg } from 'three/src/math/MathUtils'
 import { getArtifactFromRange, codeRefFromRange } from 'lang/std/artifactGraph'
 
@@ -624,7 +629,7 @@ export class SceneEntities {
 
       const startRange = _node1.node.start
       const endRange = _node1.node.end
-      const sourceRange: SourceRange = [startRange, endRange, true]
+      const sourceRange = topLevelRange(startRange, endRange)
       const selection: Selections = computeSelectionFromSourceRangeAndAST(
         sourceRange,
         maybeModdedAst
@@ -1261,110 +1266,98 @@ export class SceneEntities {
     const groupOfDrafts = new Group()
     groupOfDrafts.name = 'circle-3-point-group'
     groupOfDrafts.position.copy(sketchOrigin)
+
     // lee: I'm keeping this here as a developer gotchya:
-    // Do not reorient your surfaces to the intersection plane. Your points are
-    // already in 3D space, not 2D. If you intersect say XZ, you want the points
-    // to continue to live at the 3D intersection point, not be rotated to end
-    // up elsewhere!
-    // groupOfDrafts.setRotationFromQuaternion(orientation)
+    // If you use 3D points, do not rotate anything.
+    // If you use 2D points (easier to deal with, generally do this!), then
+    // rotate the group just like this! Remember to rotate other groups too!
+    groupOfDrafts.setRotationFromQuaternion(orientation)
     this.scene.add(groupOfDrafts)
 
-    const DRAFT_POINT_RADIUS = 6
+    // How large the points on the circle will render as
+    const DRAFT_POINT_RADIUS = 10 // px
 
-    const createPoint = (center: Vector3): number => {
+    // The target of our dragging
+    let target: Object3D | undefined = undefined
+
+    // The KCL this will generate.
+    const kclCircle3Point = parse(`circleThreePoint(
+      p1 = [0.0, 0.0],
+      p2 = [0.0, 0.0],
+      p3 = [0.0, 0.0],
+    )`)
+
+    const createPoint = (
+      center: Vector3,
+      opts?: { noInteraction?: boolean }
+    ): Mesh => {
       const geometry = new SphereGeometry(DRAFT_POINT_RADIUS)
       const color = getThemeColorForThreeJs(sceneInfra._theme)
-      const material = new MeshBasicMaterial({ color })
+
+      const material = new MeshBasicMaterial({
+        color: opts?.noInteraction
+          ? sceneInfra._theme === 'light'
+            ? new Color(color).multiplyScalar(0.15)
+            : new Color(0x010101).multiplyScalar(2000)
+          : color,
+      })
 
       const mesh = new Mesh(geometry, material)
-      mesh.userData = { type: CIRCLE_3_POINT_DRAFT_POINT }
+      mesh.userData = {
+        type: opts?.noInteraction ? 'ghost' : CIRCLE_3_POINT_DRAFT_POINT,
+      }
+      mesh.renderOrder = 1000
       mesh.layers.set(SKETCH_LAYER)
       mesh.position.copy(center)
       mesh.scale.set(scale, scale, scale)
       mesh.renderOrder = 100
 
-      groupOfDrafts.add(mesh)
-
-      return mesh.id
+      return mesh
     }
 
-    const circle3Point = (
-      points: Vector2[]
-    ): undefined | { center: Vector3; radius: number } => {
-      // A 3-point circle is undefined if it doesn't have 3 points :)
-      if (points.length !== 3) return undefined
-
-      // y = (i/j)(x-h) + b
-      // i and j variables for the slopes
-      const i = [points[1].x - points[0].x, points[2].x - points[1].x]
-      const j = [points[1].y - points[0].y, points[2].y - points[1].y]
-
-      // Our / threejs coordinate system affects this a lot. If you take this
-      // code into a different code base, you may have to adjust a/b to being
-      // -1/a/b, b/a, etc! In this case, a/-b did the trick.
-      const m = [i[0] / -j[0], i[1] / -j[1]]
-
-      const h = [
-        (points[0].x + points[1].x) / 2,
-        (points[1].x + points[2].x) / 2,
-      ]
-      const b = [
-        (points[0].y + points[1].y) / 2,
-        (points[1].y + points[2].y) / 2,
-      ]
-
-      // Algebraically derived
-      const x = (-m[0] * h[0] + b[0] - b[1] + m[1] * h[1]) / (m[1] - m[0])
-      const y = m[0] * (x - h[0]) + b[0]
-
-      const center = new Vector3(x, y, 0)
-      const radius = Math.sqrt((points[1].x - x) ** 2 + (points[1].y - y) ** 2)
-
-      return {
-        center,
-        radius,
-      }
-    }
-
-    // TO BE SHORT LIVED: unused function to draw the circle and lines.
-    // @ts-ignore
-    // eslint-disable-next-line
-    const createCircle3Point = (points: Vector2[]) => {
-      const circleParams = circle3Point(points)
-
-      // A circle cannot be created for these points.
-      if (!circleParams) return
+    const createCircle3PointGraphic = async (
+      points: Vector2[],
+      center: Vector2,
+      radius: number
+    ) => {
+      if (
+        Number.isNaN(radius) ||
+        Number.isNaN(center.x) ||
+        Number.isNaN(center.y)
+      )
+        return
 
       const color = getThemeColorForThreeJs(sceneInfra._theme)
-      const geometryCircle = createArcGeometry({
-        center: [circleParams.center.x, circleParams.center.y],
-        radius: circleParams.radius,
-        startAngle: 0,
-        endAngle: Math.PI * 2,
-        ccw: true,
-        isDashed: true,
-        scale,
+      const lineCircle = createCircleGeometry({
+        center: [center.x, center.y],
+        radius,
+        color,
+        isDashed: false,
+        scale: 1,
       })
-      const materialCircle = new MeshBasicMaterial({ color })
+      lineCircle.userData = { type: CIRCLE_3_POINT_DRAFT_CIRCLE }
+      lineCircle.layers.set(SKETCH_LAYER)
+      // devnote: it's a mistake to use these with EllipseCurve :)
+      // lineCircle.position.set(center.x, center.y, 0)
+      // lineCircle.scale.set(scale, scale, scale)
 
       if (groupCircle) groupOfDrafts.remove(groupCircle)
       groupCircle = new Group()
       groupCircle.renderOrder = 1
+      groupCircle.add(lineCircle)
 
-      const meshCircle = new Mesh(geometryCircle, materialCircle)
-      meshCircle.userData = { type: CIRCLE_3_POINT_DRAFT_CIRCLE }
-      meshCircle.layers.set(SKETCH_LAYER)
-      meshCircle.position.set(circleParams.center.x, circleParams.center.y, 0)
-      meshCircle.scale.set(scale, scale, scale)
-      groupCircle.add(meshCircle)
+      const pointMesh = createPoint(new Vector3(center.x, center.y, 0), {
+        noInteraction: true,
+      })
+      groupCircle.add(pointMesh)
 
       const geometryPolyLine = new BufferGeometry().setFromPoints([
-        ...points,
-        points[0],
+        ...points.map((p) => new Vector3(p.x, p.y, 0)),
+        new Vector3(points[0].x, points[0].y, 0),
       ])
       const materialPolyLine = new LineDashedMaterial({
         color,
-        scale,
+        scale: 1 / scale,
         dashSize: 6,
         gapSize: 6,
       })
@@ -1375,13 +1368,146 @@ export class SceneEntities {
       groupOfDrafts.add(groupCircle)
     }
 
-    // The target of our dragging
-    let target: Object3D | undefined = undefined
+    const insertCircle3PointKclIntoAstSnapshot = (
+      points: Vector2[]
+    ): Program => {
+      if (err(kclCircle3Point) || kclCircle3Point.program === null)
+        return kclManager.ast
+      if (kclCircle3Point.program.body[0].type !== 'ExpressionStatement')
+        return kclManager.ast
+      if (
+        kclCircle3Point.program.body[0].expression.type !== 'CallExpressionKw'
+      )
+        return kclManager.ast
+
+      const arg = (x: LabeledArg): Literal[] | undefined => {
+        if (
+          'arg' in x &&
+          'elements' in x.arg &&
+          x.arg.type === 'ArrayExpression'
+        ) {
+          if (x.arg.elements.every((x) => x.type === 'Literal')) {
+            return x.arg.elements
+          }
+        }
+        return undefined
+      }
+
+      const kclCircle3PointArgs =
+        kclCircle3Point.program.body[0].expression.arguments
+
+      const arg0 = arg(kclCircle3PointArgs[0])
+      if (!arg0) return kclManager.ast
+      arg0[0].value = points[0].x
+      arg0[0].raw = points[0].x.toString()
+      arg0[1].value = points[0].y
+      arg0[1].raw = points[0].y.toString()
+
+      const arg1 = arg(kclCircle3PointArgs[1])
+      if (!arg1) return kclManager.ast
+      arg1[0].value = points[1].x
+      arg1[0].raw = points[1].x.toString()
+      arg1[1].value = points[1].y
+      arg1[1].raw = points[1].y.toString()
+
+      const arg2 = arg(kclCircle3PointArgs[2])
+      if (!arg2) return kclManager.ast
+      arg2[0].value = points[2].x
+      arg2[0].raw = points[2].x.toString()
+      arg2[1].value = points[2].y
+      arg2[1].raw = points[2].y.toString()
+
+      const astSnapshot = structuredClone(kclManager.ast)
+      const startSketchOnASTNode = getNodeFromPath<VariableDeclaration>(
+        astSnapshot,
+        startSketchOnASTNodePath,
+        'VariableDeclaration'
+      )
+      if (err(startSketchOnASTNode)) return astSnapshot
+
+      // It's possible we're already dealing with a PipeExpression.
+      // Modify the current one.
+      if (
+        startSketchOnASTNode.node.declaration.init.type === 'PipeExpression' &&
+        startSketchOnASTNode.node.declaration.init.body[1].type ===
+          'CallExpressionKw' &&
+        startSketchOnASTNode.node.declaration.init.body.length >= 2
+      ) {
+        startSketchOnASTNode.node.declaration.init.body[1].arguments =
+          kclCircle3Point.program.body[0].expression.arguments
+      } else {
+        // Clone a new node based on the old, and replace the old with the new.
+        const clonedStartSketchOnASTNode = structuredClone(startSketchOnASTNode)
+        startSketchOnASTNode.node.declaration.init = createPipeExpression([
+          clonedStartSketchOnASTNode.node.declaration.init,
+          kclCircle3Point.program.body[0].expression,
+        ])
+      }
+
+      // Return the `Program`
+      return astSnapshot
+    }
+
+    const updateCircle3Point = async (opts?: { execute?: true }) => {
+      const points_ = Array.from(points.values())
+      const circleParams = calculate_circle_from_3_points(
+        points_[0].x,
+        points_[0].y,
+        points_[1].x,
+        points_[1].y,
+        points_[2].x,
+        points_[2].y
+      )
+
+      if (Number.isNaN(circleParams.radius)) return
+
+      await createCircle3PointGraphic(
+        points_,
+        new Vector2(circleParams.center_x, circleParams.center_y),
+        circleParams.radius
+      )
+      const astWithNewCode = insertCircle3PointKclIntoAstSnapshot(points_)
+      const codeAsString = recast(astWithNewCode)
+      if (err(codeAsString)) return
+      codeManager.updateCodeStateEditor(codeAsString)
+    }
 
     const cleanupFn = () => {
       this.scene.remove(groupOfDrafts)
     }
 
+    // The AST node we extracted earlier may already have a circleThreePoint!
+    // Use the points in the AST as starting points.
+    const astSnapshot = structuredClone(kclManager.ast)
+    const maybeVariableDeclaration = getNodeFromPath<VariableDeclaration>(
+      astSnapshot,
+      startSketchOnASTNodePath,
+      'VariableDeclaration'
+    )
+    if (err(maybeVariableDeclaration))
+      return () => {
+        done()
+      }
+
+    const maybeCallExpressionKw = maybeVariableDeclaration.node.declaration.init
+    if (
+      maybeCallExpressionKw.type === 'PipeExpression' &&
+      maybeCallExpressionKw.body[1].type === 'CallExpressionKw' &&
+      maybeCallExpressionKw.body[1]?.callee.name === 'circleThreePoint'
+    ) {
+      maybeCallExpressionKw?.body[1].arguments
+        .map(
+          ({ arg }: any) =>
+            new Vector2(arg.elements[0].value, arg.elements[1].value)
+        )
+        .forEach((point: Vector2) => {
+          const pointMesh = createPoint(new Vector3(point.x, point.y, 0))
+          groupOfDrafts.add(pointMesh)
+          points.set(pointMesh.id, point)
+        })
+      void updateCircle3Point()
+    }
+
     sceneInfra.setCallbacks({
       async onDrag(args) {
         const draftPointsIntersected = args.intersects.filter(
@@ -1397,8 +1523,18 @@ export class SceneEntities {
         // The user was off their mark! Missed the object to select.
         if (!target) return
 
-        target.position.copy(args.intersectionPoint.threeD)
+        target.position.copy(
+          new Vector3(
+            args.intersectionPoint.twoD.x,
+            args.intersectionPoint.twoD.y,
+            0
+          )
+        )
         points.set(target.id, args.intersectionPoint.twoD)
+
+        if (points.size <= 2) return
+
+        await updateCircle3Point()
       },
       async onDragEnd(_args) {
         target = undefined
@@ -1407,45 +1543,19 @@ export class SceneEntities {
         if (points.size >= 3) return
         if (!args.intersectionPoint) return
 
-        const id = createPoint(args.intersectionPoint.threeD)
-        points.set(id, args.intersectionPoint.twoD)
-
-        if (points.size < 2) return
-
-        // We've now got 3 points, let's create our circle!
-        const astSnapshot = structuredClone(kclManager.ast)
-        let nodeQueryResult
-        nodeQueryResult = getNodeFromPath<VariableDeclaration>(
-          astSnapshot,
-          startSketchOnASTNodePath,
-          'VariableDeclaration'
+        const pointMesh = createPoint(
+          new Vector3(
+            args.intersectionPoint.twoD.x,
+            args.intersectionPoint.twoD.y,
+            0
+          )
         )
-        if (err(nodeQueryResult)) return Promise.reject(nodeQueryResult)
-        const startSketchOnASTNode = nodeQueryResult
+        groupOfDrafts.add(pointMesh)
+        points.set(pointMesh.id, args.intersectionPoint.twoD)
 
-        const circleParams = circle3Point(Array.from(points.values()))
+        if (points.size <= 2) return
 
-        if (!circleParams) return
-
-        const kclCircle3Point = parse(`circle({
-            center = [${circleParams.center.x}, ${circleParams.center.y}],
-            radius = ${circleParams.radius},
-          }, %)`)
-
-        if (err(kclCircle3Point) || kclCircle3Point.program === null) return
-        if (kclCircle3Point.program.body[0].type !== 'ExpressionStatement')
-          return
-
-        const clonedStartSketchOnASTNode = structuredClone(startSketchOnASTNode)
-        startSketchOnASTNode.node.declaration.init = createPipeExpression([
-          clonedStartSketchOnASTNode.node.declaration.init,
-          kclCircle3Point.program.body[0].expression,
-        ])
-
-        await kclManager.executeAstMock(astSnapshot)
-        await codeManager.updateEditorWithAstAndWriteToFile(astSnapshot)
-
-        done()
+        await updateCircle3Point()
       },
     })
 
@@ -1903,7 +2013,7 @@ export class SceneEntities {
         kclManager.programMemory,
         {
           type: 'sourceRange',
-          sourceRange: [node.start, node.end, true],
+          sourceRange: topLevelRange(node.start, node.end),
         },
         getChangeSketchInput()
       )
@@ -2154,7 +2264,7 @@ export class SceneEntities {
           )
           if (trap(_node, { suppress: true })) return
           const node = _node.node
-          editorManager.setHighlightRange([[node.start, node.end, true]])
+          editorManager.setHighlightRange([topLevelRange(node.start, node.end)])
           const yellow = 0xffff00
           colorSegment(selected, yellow)
           const extraSegmentGroup = parent.getObjectByName(EXTRA_SEGMENT_HANDLE)

src/clientSideScene/segments.ts

@@ -9,6 +9,9 @@ import {
   ExtrudeGeometry,
   Group,
   LineCurve3,
+  LineBasicMaterial,
+  LineDashedMaterial,
+  Line,
   Mesh,
   MeshBasicMaterial,
   NormalBufferAttributes,
@@ -1003,6 +1006,49 @@ export function createArcGeometry({
   return geo
 }
 
+// (lee) The above is much more complex than necessary.
+// I've derived the new code from:
+// https://threejs.org/docs/#api/en/extras/curves/EllipseCurve
+// I'm not sure why it wasn't done like this in the first place?
+// I don't touch the code above because it may break something else.
+export function createCircleGeometry({
+  center,
+  radius,
+  color,
+  isDashed = false,
+  scale = 1,
+}: {
+  center: Coords2d
+  radius: number
+  color: number
+  isDashed?: boolean
+  scale?: number
+}): Line {
+  const circle = new EllipseCurve(
+    center[0],
+    center[1],
+    radius,
+    radius,
+    0,
+    Math.PI * 2,
+    true,
+    scale
+  )
+  const points = circle.getPoints(75) // just enough points to not see edges.
+  const geometry = new BufferGeometry().setFromPoints(points)
+  const material = !isDashed
+    ? new LineBasicMaterial({ color })
+    : new LineDashedMaterial({
+        color,
+        scale,
+        dashSize: 6,
+        gapSize: 6,
+      })
+  const line = new Line(geometry, material)
+  line.computeLineDistances()
+  return line
+}
+
 export function dashedStraight(
   from: Coords2d,
   to: Coords2d,

src/components/AstExplorer.tsx

@@ -5,7 +5,7 @@ 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'
+import { defaultSourceRange, SourceRange, topLevelRange } from 'lang/wasm'
 
 export function AstExplorer() {
   const { context } = useModelingContext()
@@ -118,19 +118,19 @@ function DisplayObj({
         hasCursor ? 'bg-violet-100/80 dark:bg-violet-100/25' : ''
       }`}
       onMouseEnter={(e) => {
-        editorManager.setHighlightRange([[obj?.start || 0, obj.end, true]])
+        editorManager.setHighlightRange([
+          topLevelRange(obj?.start || 0, obj.end),
+        ])
         e.stopPropagation()
       }}
       onMouseMove={(e) => {
         e.stopPropagation()
-        editorManager.setHighlightRange([[obj?.start || 0, obj.end, true]])
+        editorManager.setHighlightRange([
+          topLevelRange(obj?.start || 0, obj.end),
+        ])
       }}
       onClick={(e) => {
-        const range: [number, number, boolean] = [
-          obj?.start || 0,
-          obj.end || 0,
-          true,
-        ]
+        const range = topLevelRange(obj?.start || 0, obj.end || 0)
         const idInfo = codeToIdSelections([
           { codeRef: codeRefFromRange(range, kclManager.ast) },
         ])[0]

src/components/CommandBar/CommandArgOptionInput.tsx

@@ -134,6 +134,7 @@ function CommandArgOptionInput({
           </label>
           <Combobox.Input
             id="option-input"
+            data-testid="cmd-bar-arg-value"
             ref={inputRef}
             onChange={(event) =>
               !event.target.disabled && setQuery(event.target.value)

src/components/CommandBar/CommandBar.tsx

@@ -22,6 +22,7 @@ export const CommandBar = () => {
 
   // Close the command bar when navigating
   useEffect(() => {
+    if (commandBarState.matches('Closed')) return
     commandBarSend({ type: 'Close' })
   }, [pathname])
 

src/components/CommandBar/CommandBarSelectionInput.tsx

@@ -17,7 +17,7 @@ import { StateFrom } from 'xstate'
 const semanticEntityNames: {
   [key: string]: Array<Artifact['type'] | 'defaultPlane'>
 } = {
-  face: ['wall', 'cap', 'solid2D'],
+  face: ['wall', 'cap', 'solid2d'],
   edge: ['segment', 'sweepEdge', 'edgeCutEdge'],
   point: [],
   plane: ['defaultPlane'],

src/components/CommandComboBox.tsx

@@ -4,6 +4,8 @@ import { useCommandsContext } from 'hooks/useCommandsContext'
 import { Command } from 'lib/commandTypes'
 import { useEffect, useState } from 'react'
 import { CustomIcon } from './CustomIcon'
+import { getActorNextEvents } from 'lib/utils'
+import { sortCommands } from 'lib/commandUtils'
 
 function CommandComboBox({
   options,
@@ -18,8 +20,16 @@ function CommandComboBox({
 
   const defaultOption =
     options.find((o) => 'isCurrent' in o && o.isCurrent) || null
+  // sort disabled commands to the bottom
+  const sortedOptions = options
+    .map((command) => ({
+      command,
+      disabled: optionIsDisabled(command),
+    }))
+    .sort(sortCommands)
+    .map(({ command }) => command)
 
-  const fuse = new Fuse(options, {
+  const fuse = new Fuse(sortedOptions, {
     keys: ['displayName', 'name', 'description'],
     threshold: 0.3,
     ignoreLocation: true,
@@ -27,7 +37,7 @@ function CommandComboBox({
 
   useEffect(() => {
     const results = fuse.search(query).map((result) => result.item)
-    setFilteredOptions(query.length > 0 ? results : options)
+    setFilteredOptions(query.length > 0 ? results : sortedOptions)
   }, [query])
 
   function handleSelection(command: Command) {
@@ -42,6 +52,7 @@ function CommandComboBox({
           className="w-5 h-5 bg-primary/10 dark:bg-primary text-primary dark:text-inherit"
         />
         <Combobox.Input
+          data-testid="cmd-bar-search"
           onChange={(event) => setQuery(event.target.value)}
           className="w-full bg-transparent focus:outline-none selection:bg-primary/20 dark:selection:bg-primary/40 dark:focus:outline-none"
           onKeyDown={(event) => {
@@ -73,7 +84,9 @@ function CommandComboBox({
           <Combobox.Option
             key={option.groupId + option.name + (option.displayName || '')}
             value={option}
-            className="flex items-center gap-4 px-4 py-1.5 first:mt-2 last:mb-2 ui-active:bg-primary/10 dark:ui-active:bg-chalkboard-90"
+            className="flex items-center gap-4 px-4 py-1.5 first:mt-2 last:mb-2 ui-active:bg-primary/10 dark:ui-active:bg-chalkboard-90 ui-disabled:!text-chalkboard-50"
+            disabled={optionIsDisabled(option)}
+            data-testid={`cmd-bar-option`}
           >
             {'icon' in option && option.icon && (
               <CustomIcon name={option.icon} className="w-5 h-5" />
@@ -96,3 +109,11 @@ function CommandComboBox({
 }
 
 export default CommandComboBox
+
+function optionIsDisabled(option: Command): boolean {
+  return (
+    'machineActor' in option &&
+    option.machineActor !== undefined &&
+    !getActorNextEvents(option.machineActor.getSnapshot()).includes(option.name)
+  )
+}

src/components/CustomIcon.tsx

@@ -538,6 +538,16 @@ const CustomIconMap = {
       />
     </svg>
   ),
+  helix: (
+    <svg viewBox="0 0 20 20" fill="none" xmlns="http://www.w3.org/2000/svg">
+      <path
+        fillRule="evenodd"
+        clipRule="evenodd"
+        d="M12.3796 6.35525C10.6758 5.64945 8.44129 5.27796 6.92519 5.64172C6.15726 5.82597 5.7318 6.05228 5.55779 6.21295C5.76304 6.32354 6.2288 6.43945 7.03653 6.43302C7.87009 6.42638 8.9975 6.29045 10.4229 5.9501L10.6551 6.92275C9.17724 7.27564 7.9725 7.42559 7.04449 7.43298C6.14216 7.44017 5.42343 7.31395 4.98579 7.03617C4.75792 6.89153 4.53857 6.65945 4.50435 6.32695C4.47054 5.99852 4.63374 5.72683 4.81912 5.53684C5.17998 5.16702 5.83926 4.87389 6.69188 4.66932C8.48928 4.23806 10.9508 4.68095 12.7623 5.43139C13.669 5.80697 14.4784 6.28567 14.9739 6.82869C15.2234 7.10197 15.4238 7.42493 15.4827 7.78937C15.5448 8.1741 15.4392 8.54567 15.1831 8.86785C14.9896 9.11133 14.6502 9.31092 14.327 9.47089C14.1575 9.55477 13.9707 9.63785 13.7736 9.71907C14.257 9.99254 14.6732 10.2984 14.9739 10.6279C15.2234 10.9011 15.4238 11.2241 15.4827 11.5885C15.5448 11.9733 15.4392 12.3448 15.1831 12.667C14.9896 12.9105 14.6502 13.1101 14.327 13.2701C14.1575 13.3539 13.9707 13.437 13.7735 13.5182C14.3755 13.8587 14.8991 14.2636 15.2067 14.7211L14.3767 15.2789C14.1912 15.0029 13.8109 14.6842 13.2483 14.3702C13.0112 14.2378 12.7496 14.1107 12.4694 13.9913C11.8027 14.2087 11.1417 14.3953 10.6642 14.5188L10.6552 14.5212L10.6551 14.5211C9.17724 14.874 7.9725 15.0239 7.04449 15.0313C6.14216 15.0385 5.42343 14.9123 4.98579 14.6345C4.75792 14.4899 4.53857 14.2578 4.50435 13.9253C4.47054 13.5969 4.63374 13.3252 4.81912 13.1352C5.17998 12.7653 5.83926 12.4722 6.69188 12.2677C8.12302 11.9243 9.96538 12.1368 11.5511 12.6039C11.5872 12.6145 11.6233 12.6253 11.6593 12.6363L10.0638 13.2745C8.93153 13.0645 7.80454 13.0291 6.92519 13.2401C6.15727 13.4243 5.73181 13.6506 5.5578 13.8113C5.76305 13.9219 6.2288 14.0378 7.03653 14.0313C7.8692 14.0247 8.99509 13.8891 10.4183 13.5495C10.5419 13.5175 10.678 13.4812 10.8233 13.4412C10.8184 13.4399 10.8134 13.4387 10.8085 13.4374L12.6 12.9L12.5922 12.8948C12.6584 12.8718 12.7243 12.8485 12.7894 12.825C13.2047 12.6754 13.5845 12.5217 13.8834 12.3738C14.2059 12.2142 14.359 12.0967 14.4003 12.0448C14.4964 11.9239 14.509 11.832 14.4955 11.748C14.4786 11.6437 14.4094 11.4927 14.2353 11.302C13.8963 10.9305 13.2766 10.536 12.4694 10.1921C11.8027 10.4096 11.1417 10.5962 10.6642 10.7197L10.6552 10.722L10.6551 10.7219C9.17724 11.0748 7.9725 11.2248 7.04449 11.2322C6.14216 11.2393 5.42343 11.1131 4.98579 10.8353C4.75792 10.6907 4.53857 10.4586 4.50435 10.1261C4.47054 9.79768 4.63374 9.526 4.81912 9.33601C5.17998 8.96618 5.83926 8.67306 6.69188 8.46848C8.14467 8.11991 10.0313 8.34242 11.6579 8.83682L10.0624 9.47503C8.9375 9.26666 7.80922 9.22878 6.92519 9.44089C6.15726 9.62514 5.7318 9.85144 5.55779 10.0121C5.76304 10.1227 6.2288 10.2386 7.03653 10.2322C7.86921 10.2255 8.9951 10.0899 10.4183 9.75035C10.542 9.71834 10.6781 9.68201 10.8235 9.64197L10.8072 9.63784L12.6 9.1L12.593 9.09536C12.659 9.0724 12.7245 9.04921 12.7894 9.02583C13.2047 8.87627 13.5845 8.72256 13.8834 8.57464C14.2059 8.41505 14.359 8.29757 14.4003 8.24564C14.4964 8.1247 14.509 8.0328 14.4955 7.94882C14.4786 7.84455 14.4094 7.69357 14.2353 7.50279C13.8839 7.11769 13.2307 6.7078 12.3796 6.35525ZM5.47539 9.95537C5.47546 9.95536 5.47623 9.95615 5.47745 9.95779C5.47592 9.9562 5.47531 9.95538 5.47539 9.95537ZM5.49369 10.0846C5.49289 10.0866 5.49232 10.0876 5.49223 10.0876C5.49215 10.0877 5.49255 10.0866 5.49369 10.0846ZM5.47539 13.7545C5.47546 13.7545 5.47623 13.7553 5.47745 13.757C5.47592 13.7554 5.47531 13.7546 5.47539 13.7545ZM5.49369 13.8838C5.49289 13.8858 5.49232 13.8868 5.49223 13.8868C5.49215 13.8868 5.49255 13.8858 5.49369 13.8838ZM5.47539 6.1562C5.47546 6.15619 5.47623 6.15698 5.47745 6.15862C5.47592 6.15704 5.47531 6.15622 5.47539 6.1562ZM5.49369 6.28544C5.49289 6.28746 5.49232 6.28848 5.49223 6.28848C5.49215 6.28849 5.49255 6.28748 5.49369 6.28544Z"
+        fill="currentColor"
+      />
+    </svg>
+  ),
   hole: (
     <svg
       viewBox="0 0 20 20"

src/components/DebugFeatureTree.tsx

@@ -1,10 +1,7 @@
 import { useMemo } from 'react'
 import { engineCommandManager } from 'lib/singletons'
-import {
-  ArtifactGraph,
-  expandPlane,
-  PlaneArtifactRich,
-} from 'lang/std/artifactGraph'
+import { expandPlane, PlaneArtifactRich } from 'lang/std/artifactGraph'
+import { ArtifactGraph } from 'lang/wasm'
 import { DebugDisplayArray, GenericObj } from './DebugDisplayObj'
 
 export function DebugFeatureTree() {

src/components/FileMachineProvider.tsx

@@ -57,7 +57,9 @@ export const FileMachineProvider = ({
   useEffect(() => {
     markOnce('code/didLoadFile')
     async function fetchKclSamples() {
-      setKclSamples(await getKclSamplesManifest())
+      const manifest = await getKclSamplesManifest()
+      const filteredFiles = manifest.filter((file) => !file.multipleFiles)
+      setKclSamples(filteredFiles)
     }
     fetchKclSamples().catch(reportError)
   }, [])
@@ -324,7 +326,7 @@ export const FileMachineProvider = ({
           }
         },
         kclSamples.map((sample) => ({
-          value: sample.file,
+          value: sample.pathFromProjectDirectoryToFirstFile,
           name: sample.title,
         }))
       ).filter(

src/components/HelpMenu.tsx

@@ -148,6 +148,7 @@ function HelpMenuItem({
   return (
     <li className="p-0 m-0">
       {as === 'a' ? (
+        // eslint-disable-next-line jsx-a11y/no-static-element-interactions
         <a
           {...(props as React.ComponentProps<'a'>)}
           onClick={openExternalBrowserIfDesktop(

src/components/ModelingMachineProvider.tsx

@@ -111,7 +111,7 @@ export const ModelingMachineProvider = ({
     auth,
     settings: {
       context: {
-        app: { theme, enableSSAO },
+        app: { theme, enableSSAO, allowOrbitInSketchMode },
         modeling: {
           defaultUnit,
           cameraProjection,
@@ -121,6 +121,7 @@ export const ModelingMachineProvider = ({
       },
     },
   } = useSettingsAuthContext()
+  const previousAllowOrbitInSketchMode = useRef(allowOrbitInSketchMode.current)
   const navigate = useNavigate()
   const { context, send: fileMachineSend } = useFileContext()
   const { file } = useLoaderData() as IndexLoaderData
@@ -634,7 +635,8 @@ export const ModelingMachineProvider = ({
             input.plane
           )
           await kclManager.updateAst(modifiedAst, false)
-          sceneInfra.camControls.enableRotate = false
+          sceneInfra.camControls.enableRotate =
+            sceneInfra.camControls._setting_allowOrbitInSketchMode
           sceneInfra.camControls.syncDirection = 'clientToEngine'
 
           await letEngineAnimateAndSyncCamAfter(
@@ -647,6 +649,7 @@ export const ModelingMachineProvider = ({
             zAxis: input.zAxis,
             yAxis: input.yAxis,
             origin: [0, 0, 0],
+            animateTargetId: input.planeId,
           }
         }),
         'animate-to-sketch': fromPromise(
@@ -671,6 +674,7 @@ export const ModelingMachineProvider = ({
               origin: info.sketchDetails.origin.map(
                 (a) => a / sceneInfra._baseUnitMultiplier
               ) as [number, number, number],
+              animateTargetId: info?.sketchDetails?.faceId || '',
             }
           }
         ),
@@ -1188,6 +1192,41 @@ export const ModelingMachineProvider = ({
     }
   }, [engineCommandManager.engineConnection, modelingSend])
 
+  useEffect(() => {
+    // Only trigger this if the state actually changes, if it stays the same do not reload the camera
+    if (
+      previousAllowOrbitInSketchMode.current === allowOrbitInSketchMode.current
+    ) {
+      //no op
+      previousAllowOrbitInSketchMode.current = allowOrbitInSketchMode.current
+      return
+    }
+    const inSketchMode = modelingState.matches('Sketch')
+
+    // If you are in sketch mode and you disable the orbit, return back to the normal view to the target
+    if (!allowOrbitInSketchMode.current) {
+      const targetId = modelingState.context.sketchDetails?.animateTargetId
+      if (inSketchMode && targetId) {
+        letEngineAnimateAndSyncCamAfter(engineCommandManager, targetId)
+          .then(() => {})
+          .catch((e) => {
+            console.error(
+              'failed to sync engine and client scene after disabling allow orbit in sketch mode'
+            )
+            console.error(e)
+          })
+      }
+    }
+
+    // While you are in sketch mode you should be able to control the enable rotate
+    // Once you exit it goes back to normal
+    if (inSketchMode) {
+      sceneInfra.camControls.enableRotate = allowOrbitInSketchMode.current
+    }
+
+    previousAllowOrbitInSketchMode.current = allowOrbitInSketchMode.current
+  }, [allowOrbitInSketchMode])
+
   // Allow using the delete key to delete solids
   useHotkeys(['backspace', 'delete', 'del'], () => {
     modelingSend({ type: 'Delete selection' })

src/components/ModelingSidebar/ModelingPanes/KclEditorMenu.tsx

@@ -18,6 +18,7 @@ export const KclEditorMenu = ({ children }: PropsWithChildren) => {
 
   return (
     <Menu>
+      {/* eslint-disable-next-line jsx-a11y/no-static-element-interactions */}
       <div
         className="relative"
         onClick={(e) => {

src/components/ProjectsContextProvider.tsx

@@ -18,6 +18,7 @@ import {
   getNextProjectIndex,
   interpolateProjectNameWithIndex,
   doesProjectNameNeedInterpolated,
+  getUniqueProjectName,
 } from 'lib/desktopFS'
 import { useSettingsAuthContext } from 'hooks/useSettingsAuthContext'
 import useStateMachineCommands from 'hooks/useStateMachineCommands'
@@ -195,16 +196,12 @@ const ProjectsContextDesktop = ({
               : settings.projects.defaultProjectName.current
           ).trim()
 
-          if (doesProjectNameNeedInterpolated(name)) {
-            const nextIndex = getNextProjectIndex(name, input.projects)
-            name = interpolateProjectNameWithIndex(name, nextIndex)
-          }
-
-          await createNewProjectDirectory(name)
+          const uniqueName = getUniqueProjectName(name, input.projects)
+          await createNewProjectDirectory(uniqueName)
 
           return {
-            message: `Successfully created "${name}"`,
-            name,
+            message: `Successfully created "${uniqueName}"`,
+            name: uniqueName,
           }
         }),
         renameProject: fromPromise(async ({ input }) => {

src/components/SettingsAuthProvider.tsx

@@ -137,6 +137,11 @@ export const SettingsAuthProviderBase = ({
           sceneInfra.theme = opposingTheme
           sceneEntitiesManager.updateSegmentBaseColor(opposingTheme)
         },
+        setAllowOrbitInSketchMode: ({ context }) => {
+          sceneInfra.camControls._setting_allowOrbitInSketchMode =
+            context.app.allowOrbitInSketchMode.current
+          // ModelingMachineProvider will do a use effect to trigger the camera engine sync
+        },
         toastSuccess: ({ event }) => {
           if (!('data' in event)) return
           const eventParts = event.type.replace(/^set./, '').split('.') as [

src/components/Stream.tsx

@@ -301,7 +301,7 @@ export const Stream = () => {
           return
         }
         const path = getArtifactOfTypes(
-          { key: entity_id, types: ['path', 'solid2D', 'segment'] },
+          { key: entity_id, types: ['path', 'solid2d', 'segment'] },
           engineCommandManager.artifactGraph
         )
         if (err(path)) {
@@ -313,6 +313,7 @@ export const Stream = () => {
   }
 
   return (
+    // eslint-disable-next-line jsx-a11y/no-static-element-interactions
     <div
       ref={videoWrapperRef}
       className="absolute inset-0 z-0"

src/components/Toolbar/RemoveConstrainingValues.tsx

@@ -1,6 +1,6 @@
 import { toolTips } from 'lang/langHelpers'
 import { Selection, Selections } from 'lib/selections'
-import { PathToNode, Program, Expr } from '../../lang/wasm'
+import { PathToNode, Program, Expr, topLevelRange } from '../../lang/wasm'
 import { getNodeFromPath } from '../../lang/queryAst'
 import {
   PathToNodeMap,
@@ -41,7 +41,7 @@ export function removeConstrainingValuesInfo({
         graphSelections: nodes.map(
           (node): Selection => ({
             codeRef: codeRefFromRange(
-              [node.start, node.end, true],
+              topLevelRange(node.start, node.end),
               kclManager.ast
             ),
           })

src/hooks/useStateMachineCommands.ts

@@ -1,5 +1,5 @@
 import { useEffect } from 'react'
-import { AnyStateMachine, Actor, StateFrom } from 'xstate'
+import { AnyStateMachine, Actor, StateFrom, EventFrom } from 'xstate'
 import { createMachineCommand } from '../lib/createMachineCommand'
 import { useCommandsContext } from './useCommandsContext'
 import { modelingMachine } from 'machines/modelingMachine'
@@ -15,7 +15,6 @@ import { useKclContext } from 'lang/KclProvider'
 import { useNetworkContext } from 'hooks/useNetworkContext'
 import { NetworkHealthState } from 'hooks/useNetworkStatus'
 import { useAppState } from 'AppState'
-import { getActorNextEvents } from 'lib/utils'
 
 // This might not be necessary, AnyStateMachine from xstate is working
 export type AllMachines =
@@ -60,21 +59,21 @@ export default function useStateMachineCommands<
         overallState !== NetworkHealthState.Weak) ||
       isExecuting ||
       !isStreamReady
-    const newCommands = getActorNextEvents(state)
+    const newCommands = Object.keys(commandBarConfig || {})
       .filter((_) => !allCommandsRequireNetwork || !disableAllButtons)
-      .filter((e) => !['done.', 'error.'].some((n) => e.includes(n)))
-      .flatMap((type) =>
-        createMachineCommand<T, S>({
+      .flatMap((type) => {
+        const typeWithProperType = type as EventFrom<T>['type']
+        return createMachineCommand<T, S>({
           // The group is the owner machine's ID.
           groupId: machineId,
-          type,
+          type: typeWithProperType,
           state,
           send,
           actor,
           commandBarConfig,
           onCancel,
         })
-      )
+      })
       .filter((c) => c !== null) as Command[] // TS isn't smart enough to know this filter removes nulls
 
     commandBarSend({ type: 'Add commands', data: { commands: newCommands } })
@@ -85,5 +84,5 @@ export default function useStateMachineCommands<
         data: { commands: newCommands },
       })
     }
-  }, [state, overallState, isExecuting, isStreamReady])
+  }, [overallState, isExecuting, isStreamReady])
 }

src/lang/KclSingleton.ts

@@ -22,6 +22,7 @@ import {
   ProgramMemory,
   recast,
   SourceRange,
+  topLevelRange,
 } from 'lang/wasm'
 import { getNodeFromPath } from './queryAst'
 import { codeManager, editorManager, sceneInfra } from 'lib/singletons'
@@ -376,11 +377,7 @@ export class KclManager {
     }
     this.ast = { ...ast }
     // updateArtifactGraph relies on updated executeState/programMemory
-    await this.engineCommandManager.updateArtifactGraph(
-      this.ast,
-      execState.artifactCommands,
-      execState.artifacts
-    )
+    this.engineCommandManager.updateArtifactGraph(execState.artifactGraph)
     this._executeCallback()
     if (!isInterrupted) {
       sceneInfra.modelingSend({ type: 'code edit during sketch' })
@@ -473,7 +470,7 @@ export class KclManager {
           ...artifact,
           codeRef: {
             ...artifact.codeRef,
-            range: [node.start, node.end, true],
+            range: topLevelRange(node.start, node.end),
           },
         })
       }
@@ -594,7 +591,7 @@ export class KclManager {
         if (start && end) {
           returnVal.graphSelections.push({
             codeRef: {
-              range: [start, end, true],
+              range: topLevelRange(start, end),
               pathToNode: path,
             },
           })

src/lang/errors.test.ts

@@ -1,4 +1,5 @@
 import { kclErrorsToDiagnostics, KCLError } from './errors'
+import { defaultArtifactGraph, topLevelRange } from 'lang/wasm'
 
 describe('test kclErrToDiagnostic', () => {
   it('converts KCL errors to CodeMirror diagnostics', () => {
@@ -8,18 +9,20 @@ describe('test kclErrToDiagnostic', () => {
         message: '',
         kind: 'semantic',
         msg: 'Semantic error',
-        sourceRange: [0, 1, true],
+        sourceRange: topLevelRange(0, 1),
         operations: [],
         artifactCommands: [],
+        artifactGraph: defaultArtifactGraph(),
       },
       {
         name: '',
         message: '',
         kind: 'type',
         msg: 'Type error',
-        sourceRange: [4, 5, true],
+        sourceRange: topLevelRange(4, 5),
         operations: [],
         artifactCommands: [],
+        artifactGraph: defaultArtifactGraph(),
       },
     ]
     const diagnostics = kclErrorsToDiagnostics(errors)

src/lang/errors.ts

@@ -5,7 +5,13 @@ 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 { ArtifactCommand, SourceRange } from 'lang/wasm'
+import {
+  ArtifactCommand,
+  ArtifactGraph,
+  defaultArtifactGraph,
+  isTopLevelModule,
+  SourceRange,
+} from 'lang/wasm'
 import { Operation } from 'wasm-lib/kcl/bindings/Operation'
 
 type ExtractKind<T> = T extends { kind: infer K } ? K : never
@@ -15,13 +21,15 @@ export class KCLError extends Error {
   msg: string
   operations: Operation[]
   artifactCommands: ArtifactCommand[]
+  artifactGraph: ArtifactGraph
 
   constructor(
     kind: ExtractKind<RustKclError> | 'name',
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
     super()
     this.kind = kind
@@ -29,6 +37,7 @@ export class KCLError extends Error {
     this.sourceRange = sourceRange
     this.operations = operations
     this.artifactCommands = artifactCommands
+    this.artifactGraph = artifactGraph
     Object.setPrototypeOf(this, KCLError.prototype)
   }
 }
@@ -38,9 +47,17 @@ export class KCLLexicalError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('lexical', msg, sourceRange, operations, artifactCommands)
+    super(
+      'lexical',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
@@ -50,9 +67,17 @@ export class KCLInternalError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('internal', msg, sourceRange, operations, artifactCommands)
+    super(
+      'internal',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
@@ -62,9 +87,17 @@ export class KCLSyntaxError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('syntax', msg, sourceRange, operations, artifactCommands)
+    super(
+      'syntax',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLSyntaxError.prototype)
   }
 }
@@ -74,9 +107,17 @@ export class KCLSemanticError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('semantic', msg, sourceRange, operations, artifactCommands)
+    super(
+      'semantic',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLSemanticError.prototype)
   }
 }
@@ -86,9 +127,10 @@ export class KCLTypeError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('type', msg, sourceRange, operations, artifactCommands)
+    super('type', msg, sourceRange, operations, artifactCommands, artifactGraph)
     Object.setPrototypeOf(this, KCLTypeError.prototype)
   }
 }
@@ -98,9 +140,17 @@ export class KCLUnimplementedError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('unimplemented', msg, sourceRange, operations, artifactCommands)
+    super(
+      'unimplemented',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLUnimplementedError.prototype)
   }
 }
@@ -110,9 +160,17 @@ export class KCLUnexpectedError extends KCLError {
     msg: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
-    super('unexpected', msg, sourceRange, operations, artifactCommands)
+    super(
+      'unexpected',
+      msg,
+      sourceRange,
+      operations,
+      artifactCommands,
+      artifactGraph
+    )
     Object.setPrototypeOf(this, KCLUnexpectedError.prototype)
   }
 }
@@ -122,14 +180,16 @@ export class KCLValueAlreadyDefined extends KCLError {
     key: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
     super(
       'name',
       `Key ${key} was already defined elsewhere`,
       sourceRange,
       operations,
-      artifactCommands
+      artifactCommands,
+      artifactGraph
     )
     Object.setPrototypeOf(this, KCLValueAlreadyDefined.prototype)
   }
@@ -140,14 +200,16 @@ export class KCLUndefinedValueError extends KCLError {
     key: string,
     sourceRange: SourceRange,
     operations: Operation[],
-    artifactCommands: ArtifactCommand[]
+    artifactCommands: ArtifactCommand[],
+    artifactGraph: ArtifactGraph
   ) {
     super(
       'name',
       `Key ${key} has not been defined`,
       sourceRange,
       operations,
-      artifactCommands
+      artifactCommands,
+      artifactGraph
     )
     Object.setPrototypeOf(this, KCLUndefinedValueError.prototype)
   }
@@ -167,9 +229,10 @@ export function lspDiagnosticsToKclErrors(
         new KCLError(
           'unexpected',
           message,
-          [posToOffset(doc, range.start)!, posToOffset(doc, range.end)!, true],
+          [posToOffset(doc, range.start)!, posToOffset(doc, range.end)!, 0],
           [],
-          []
+          [],
+          defaultArtifactGraph()
         )
     )
     .sort((a, b) => {
@@ -193,7 +256,7 @@ export function kclErrorsToDiagnostics(
   errors: KCLError[]
 ): CodeMirrorDiagnostic[] {
   return errors
-    ?.filter((err) => err.sourceRange[2])
+    ?.filter((err) => isTopLevelModule(err.sourceRange))
     .map((err) => {
       return {
         from: err.sourceRange[0],
@@ -208,7 +271,7 @@ export function complilationErrorsToDiagnostics(
   errors: CompilationError[]
 ): CodeMirrorDiagnostic[] {
   return errors
-    ?.filter((err) => err.sourceRange[2] === 0)
+    ?.filter((err) => isTopLevelModule(err.sourceRange))
     .map((err) => {
       let severity: any = 'error'
       if (err.severity === 'Warning') {

src/lang/executor.test.ts

@@ -6,6 +6,8 @@ import {
   Sketch,
   initPromise,
   sketchFromKclValue,
+  defaultArtifactGraph,
+  topLevelRange,
 } from './wasm'
 import { enginelessExecutor } from '../lib/testHelpers'
 import { KCLError } from './errors'
@@ -480,9 +482,10 @@ const theExtrude = startSketchOn('XY')
       new KCLError(
         'undefined_value',
         'memory item key `myVarZ` is not defined',
-        [129, 135, true],
+        topLevelRange(129, 135),
         [],
-        []
+        [],
+        defaultArtifactGraph()
       )
     )
   })

src/lang/getNodePathFromSourceRange.test.ts

@@ -1,5 +1,12 @@
 import { getNodePathFromSourceRange, getNodeFromPath } from './queryAst'
-import { Identifier, assertParse, initPromise, Parameter } from './wasm'
+import {
+  Identifier,
+  assertParse,
+  initPromise,
+  Parameter,
+  SourceRange,
+  topLevelRange,
+} from './wasm'
 import { err } from 'lib/trap'
 
 beforeAll(async () => {
@@ -17,11 +24,10 @@ const sk3 = startSketchAt([0, 0])
 `
     const subStr = 'lineTo([3, 4], %, $yo)'
     const lineToSubstringIndex = code.indexOf(subStr)
-    const sourceRange: [number, number, boolean] = [
+    const sourceRange = topLevelRange(
       lineToSubstringIndex,
-      lineToSubstringIndex + subStr.length,
-      true,
-    ]
+      lineToSubstringIndex + subStr.length
+    )
 
     const ast = assertParse(code)
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)
@@ -29,7 +35,7 @@ const sk3 = startSketchAt([0, 0])
     if (err(_node)) throw _node
     const { node } = _node
 
-    expect([node.start, node.end, true]).toEqual(sourceRange)
+    expect(topLevelRange(node.start, node.end)).toEqual(sourceRange)
     expect(node.type).toBe('CallExpression')
   })
   it('gets path right for function definition params', () => {
@@ -45,11 +51,7 @@ 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] = [
-      subStrIndex,
-      subStrIndex + 'pos'.length,
-      true,
-    ]
+    const sourceRange = topLevelRange(subStrIndex, subStrIndex + 'pos'.length)
 
     const ast = assertParse(code)
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)
@@ -81,11 +83,7 @@ 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] = [
-      subStrIndex,
-      subStrIndex + 'scale'.length,
-      true,
-    ]
+    const sourceRange = topLevelRange(subStrIndex, subStrIndex + 'scale'.length)
 
     const ast = assertParse(code)
     const nodePath = getNodePathFromSourceRange(ast, sourceRange)

src/lang/kclSamples.test.ts

@@ -1,79 +1,81 @@
 import { assertParse, initPromise, programMemoryInit } from './wasm'
 import { enginelessExecutor } from '../lib/testHelpers'
-// These unit tests makes web requests to a public github repository.
+
+import path from 'node:path'
+import fs from 'node:fs/promises'
+import child_process from 'node:child_process'
+
+// The purpose of these tests is to act as a first line of defense
+// if something gets real screwy with our KCL ecosystem.
+// THESE TESTS ONLY RUN UNDER A NODEJS ENVIRONMENT. They DO NOT
+// test under our application.
+
+const DIR_KCL_SAMPLES = 'kcl-samples'
+const URL_GIT_KCL_SAMPLES = 'https://github.com/KittyCAD/kcl-samples.git'
 
 interface KclSampleFile {
   file: string
+  pathFromProjectDirectoryToFirstFile: string
   title: string
   filename: string
   description: string
 }
 
+try {
+  // @ts-expect-error
+  await fs.rm(DIR_KCL_SAMPLES, { recursive: true })
+} catch (e) {
+  console.log(e)
+}
+
+child_process.spawnSync('git', ['clone', URL_GIT_KCL_SAMPLES, DIR_KCL_SAMPLES])
+
+// @ts-expect-error
+let files = await fs.readdir(DIR_KCL_SAMPLES)
+// @ts-expect-error
+const manifestJsonStr = await fs.readFile(
+  path.resolve(DIR_KCL_SAMPLES, 'manifest.json'),
+  'utf-8'
+)
+const manifest = JSON.parse(manifestJsonStr)
+
+process.chdir(DIR_KCL_SAMPLES)
+
 beforeAll(async () => {
   await initPromise
 })
 
-// Only used to actually fetch an older version of KCL code that will break in the parser.
-/* eslint-disable @typescript-eslint/no-unused-vars */
-async function getBrokenSampleCodeForLocalTesting() {
-  const result = await fetch(
-    'https://raw.githubusercontent.com/KittyCAD/kcl-samples/5ccd04a1773ebdbfd02684057917ce5dbe0eaab3/80-20-rail.kcl'
-  )
-  const text = await result.text()
-  return text
-}
+afterAll(async () => {
+  try {
+    process.chdir('..')
+    await fs.rm(DIR_KCL_SAMPLES, { recursive: true })
+  } catch (e) {}
+})
 
-async function getKclSampleCodeFromGithub(file: string): Promise<string> {
-  const result = await fetch(
-    `https://raw.githubusercontent.com/KittyCAD/kcl-samples/refs/heads/main/${file}/${file}.kcl`
-  )
-  const text = await result.text()
-  return text
-}
+afterEach(() => {
+  process.chdir('..')
+})
 
-async function getFileNamesFromManifestJSON(): Promise<KclSampleFile[]> {
-  const result = await fetch(
-    'https://raw.githubusercontent.com/KittyCAD/kcl-samples/refs/heads/main/manifest.json'
-  )
-  const json = await result.json()
-  json.forEach((file: KclSampleFile) => {
-    const filenameWithoutExtension = file.file.split('.')[0]
-    file.filename = filenameWithoutExtension
-  })
-  return json
-}
-
-// Value to use across all tests!
-let files: KclSampleFile[] = []
-
-describe('Test KCL Samples from public Github repository', () => {
-  describe('When parsing source code', () => {
-    // THIS RUNS ACROSS OTHER TESTS!
-    it('should fetch files', async () => {
-      files = await getFileNamesFromManifestJSON()
-    })
-    // Run through all of the files in the manifest json. This will allow us to be automatically updated
-    // with the latest changes in github. We won't be hard coding the filenames
-    files.forEach((file: KclSampleFile) => {
-      it(`should parse ${file.filename} without errors`, async () => {
-        const code = await getKclSampleCodeFromGithub(file.filename)
-        assertParse(code)
-      }, 1000)
-    })
-  })
-
-  describe('when performing enginelessExecutor', () => {
-    it(
-      'should run through all the files',
-      async () => {
-        for (let i = 0; i < files.length; i++) {
-          const file: KclSampleFile = files[i]
-          const code = await getKclSampleCodeFromGithub(file.filename)
+// The tests have to be sequential because we need to change directories
+// to support `import` working properly.
+// @ts-expect-error
+describe.sequential('Test KCL Samples from public Github repository', () => {
+  // @ts-expect-error
+  describe.sequential('when performing enginelessExecutor', () => {
+    manifest.forEach((file: KclSampleFile) => {
+      // @ts-expect-error
+      it.sequential(
+        `should execute ${file.title} (${file.file}) successfully`,
+        async () => {
+          const [dirProject, fileKcl] =
+            file.pathFromProjectDirectoryToFirstFile.split('/')
+          process.chdir(dirProject)
+          const code = await fs.readFile(fileKcl, 'utf-8')
           const ast = assertParse(code)
           await enginelessExecutor(ast, programMemoryInit())
-        }
-      },
-      files.length * 1000
-    )
+        },
+        files.length * 1000
+      )
+    })
   })
 })

src/lang/modifyAst.test.ts

@@ -1,4 +1,11 @@
-import { assertParse, recast, initPromise, Identifier } from './wasm'
+import {
+  assertParse,
+  recast,
+  initPromise,
+  Identifier,
+  SourceRange,
+  topLevelRange,
+} from './wasm'
 import {
   createLiteral,
   createIdentifier,
@@ -148,11 +155,7 @@ function giveSketchFnCallTagTestHelper(
   // making it more of an integration test, but easier to read the test intention is the goal
   const ast = assertParse(code)
   const start = code.indexOf(searchStr)
-  const range: [number, number, boolean] = [
-    start,
-    start + searchStr.length,
-    true,
-  ]
+  const range = topLevelRange(start, start + searchStr.length)
   const sketchRes = giveSketchFnCallTag(ast, range)
   if (err(sketchRes)) throw sketchRes
   const { modifiedAst, tag, isTagExisting } = sketchRes
@@ -230,7 +233,7 @@ yo2 = hmm([identifierGuy + 5])`
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
       execState.memory,
-      [startIndex, startIndex, true],
+      topLevelRange(startIndex, startIndex),
       'newVar'
     )
     const newCode = recast(modifiedAst)
@@ -244,7 +247,7 @@ yo2 = hmm([identifierGuy + 5])`
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
       execState.memory,
-      [startIndex, startIndex, true],
+      topLevelRange(startIndex, startIndex),
       'newVar'
     )
     const newCode = recast(modifiedAst)
@@ -258,7 +261,7 @@ yo2 = hmm([identifierGuy + 5])`
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
       execState.memory,
-      [startIndex, startIndex, true],
+      topLevelRange(startIndex, startIndex),
       'newVar'
     )
     const newCode = recast(modifiedAst)
@@ -272,7 +275,7 @@ yo2 = hmm([identifierGuy + 5])`
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
       execState.memory,
-      [startIndex, startIndex, true],
+      topLevelRange(startIndex, startIndex),
       'newVar'
     )
     const newCode = recast(modifiedAst)
@@ -286,7 +289,7 @@ yo2 = hmm([identifierGuy + 5])`
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
       execState.memory,
-      [startIndex, startIndex, true],
+      topLevelRange(startIndex, startIndex),
       'newVar'
     )
     const newCode = recast(modifiedAst)
@@ -306,18 +309,16 @@ describe('testing sketchOnExtrudedFace', () => {
     const ast = assertParse(code)
 
     const segmentSnippet = `line([9.7, 9.19], %)`
-    const segmentRange: [number, number, boolean] = [
+    const segmentRange = topLevelRange(
       code.indexOf(segmentSnippet),
-      code.indexOf(segmentSnippet) + segmentSnippet.length,
-      true,
-    ]
+      code.indexOf(segmentSnippet) + segmentSnippet.length
+    )
     const segmentPathToNode = getNodePathFromSourceRange(ast, segmentRange)
     const extrudeSnippet = `extrude(5 + 7, %)`
-    const extrudeRange: [number, number, boolean] = [
+    const extrudeRange = topLevelRange(
       code.indexOf(extrudeSnippet),
-      code.indexOf(extrudeSnippet) + extrudeSnippet.length,
-      true,
-    ]
+      code.indexOf(extrudeSnippet) + extrudeSnippet.length
+    )
     const extrudePathToNode = getNodePathFromSourceRange(ast, extrudeRange)
 
     const extruded = sketchOnExtrudedFace(
@@ -346,18 +347,16 @@ sketch001 = startSketchOn(part001, seg01)`)
   |> extrude(5 + 7, %)`
     const ast = assertParse(code)
     const segmentSnippet = `close(%)`
-    const segmentRange: [number, number, boolean] = [
+    const segmentRange = topLevelRange(
       code.indexOf(segmentSnippet),
-      code.indexOf(segmentSnippet) + segmentSnippet.length,
-      true,
-    ]
+      code.indexOf(segmentSnippet) + segmentSnippet.length
+    )
     const segmentPathToNode = getNodePathFromSourceRange(ast, segmentRange)
     const extrudeSnippet = `extrude(5 + 7, %)`
-    const extrudeRange: [number, number, boolean] = [
+    const extrudeRange = topLevelRange(
       code.indexOf(extrudeSnippet),
-      code.indexOf(extrudeSnippet) + extrudeSnippet.length,
-      true,
-    ]
+      code.indexOf(extrudeSnippet) + extrudeSnippet.length
+    )
     const extrudePathToNode = getNodePathFromSourceRange(ast, extrudeRange)
 
     const extruded = sketchOnExtrudedFace(
@@ -386,18 +385,16 @@ sketch001 = startSketchOn(part001, seg01)`)
   |> extrude(5 + 7, %)`
     const ast = assertParse(code)
     const sketchSnippet = `startProfileAt([3.58, 2.06], %)`
-    const sketchRange: [number, number, boolean] = [
+    const sketchRange = topLevelRange(
       code.indexOf(sketchSnippet),
-      code.indexOf(sketchSnippet) + sketchSnippet.length,
-      true,
-    ]
+      code.indexOf(sketchSnippet) + sketchSnippet.length
+    )
     const sketchPathToNode = getNodePathFromSourceRange(ast, sketchRange)
     const extrudeSnippet = `extrude(5 + 7, %)`
-    const extrudeRange: [number, number, boolean] = [
+    const extrudeRange = topLevelRange(
       code.indexOf(extrudeSnippet),
-      code.indexOf(extrudeSnippet) + extrudeSnippet.length,
-      true,
-    ]
+      code.indexOf(extrudeSnippet) + extrudeSnippet.length
+    )
     const extrudePathToNode = getNodePathFromSourceRange(ast, extrudeRange)
 
     const extruded = sketchOnExtrudedFace(
@@ -435,18 +432,16 @@ sketch001 = startSketchOn(part001, 'END')`)
     part001 = extrude(5 + 7, sketch001)`
     const ast = assertParse(code)
     const segmentSnippet = `line([4.99, -0.46], %)`
-    const segmentRange: [number, number, boolean] = [
+    const segmentRange = topLevelRange(
       code.indexOf(segmentSnippet),
-      code.indexOf(segmentSnippet) + segmentSnippet.length,
-      true,
-    ]
+      code.indexOf(segmentSnippet) + segmentSnippet.length
+    )
     const segmentPathToNode = getNodePathFromSourceRange(ast, segmentRange)
     const extrudeSnippet = `extrude(5 + 7, sketch001)`
-    const extrudeRange: [number, number, boolean] = [
+    const extrudeRange = topLevelRange(
       code.indexOf(extrudeSnippet),
-      code.indexOf(extrudeSnippet) + extrudeSnippet.length,
-      true,
-    ]
+      code.indexOf(extrudeSnippet) + extrudeSnippet.length
+    )
     const extrudePathToNode = getNodePathFromSourceRange(ast, extrudeRange)
 
     const updatedAst = sketchOnExtrudedFace(
@@ -471,11 +466,10 @@ describe('Testing deleteSegmentFromPipeExpression', () => {
     const ast = assertParse(code)
     const execState = await enginelessExecutor(ast)
     const lineOfInterest = 'line([306.21, 198.85], %, $a)'
-    const range: [number, number, boolean] = [
+    const range = topLevelRange(
       code.indexOf(lineOfInterest),
-      code.indexOf(lineOfInterest) + lineOfInterest.length,
-      true,
-    ]
+      code.indexOf(lineOfInterest) + lineOfInterest.length
+    )
     const pathToNode = getNodePathFromSourceRange(ast, range)
     const modifiedAst = deleteSegmentFromPipeExpression(
       [],
@@ -549,11 +543,10 @@ ${!replace1 ? `  |> ${line}\n` : ''}  |> angledLine([-65, ${
       const ast = assertParse(code)
       const execState = await enginelessExecutor(ast)
       const lineOfInterest = line
-      const range: [number, number, boolean] = [
+      const range = topLevelRange(
         code.indexOf(lineOfInterest),
-        code.indexOf(lineOfInterest) + lineOfInterest.length,
-        true,
-      ]
+        code.indexOf(lineOfInterest) + lineOfInterest.length
+      )
       const pathToNode = getNodePathFromSourceRange(ast, range)
       const dependentSegments = findUsesOfTagInPipe(ast, pathToNode)
       const modifiedAst = deleteSegmentFromPipeExpression(
@@ -638,11 +631,10 @@ describe('Testing removeSingleConstraintInfo', () => {
 
       const execState = await enginelessExecutor(ast)
       const lineOfInterest = expectedFinish.split('(')[0] + '('
-      const range: [number, number, boolean] = [
+      const range = topLevelRange(
         code.indexOf(lineOfInterest) + 1,
-        code.indexOf(lineOfInterest) + lineOfInterest.length,
-        true,
-      ]
+        code.indexOf(lineOfInterest) + lineOfInterest.length
+      )
       const pathToNode = getNodePathFromSourceRange(ast, range)
       let argPosition: SimplifiedArgDetails
       if (key === 'arrayIndex' && typeof value === 'number') {
@@ -692,11 +684,10 @@ describe('Testing removeSingleConstraintInfo', () => {
 
       const execState = await enginelessExecutor(ast)
       const lineOfInterest = expectedFinish.split('(')[0] + '('
-      const range: [number, number, boolean] = [
+      const range = topLevelRange(
         code.indexOf(lineOfInterest) + 1,
-        code.indexOf(lineOfInterest) + lineOfInterest.length,
-        true,
-      ]
+        code.indexOf(lineOfInterest) + lineOfInterest.length
+      )
       let argPosition: SimplifiedArgDetails
       if (key === 'arrayIndex' && typeof value === 'number') {
         argPosition = {
@@ -889,11 +880,10 @@ sketch002 = startSketchOn({
       const execState = await enginelessExecutor(ast)
 
       // deleteFromSelection
-      const range: [number, number, boolean] = [
+      const range = topLevelRange(
         codeBefore.indexOf(lineOfInterest),
-        codeBefore.indexOf(lineOfInterest) + lineOfInterest.length,
-        true,
-      ]
+        codeBefore.indexOf(lineOfInterest) + lineOfInterest.length
+      )
       const artifact = { type } as Artifact
       const newAst = await deleteFromSelection(
         ast,

src/lang/modifyAst/addEdgeTreatment.test.ts

@@ -8,6 +8,8 @@ import {
   makeDefaultPlanes,
   PipeExpression,
   VariableDeclarator,
+  SourceRange,
+  topLevelRange,
 } from '../wasm'
 import {
   EdgeTreatmentType,
@@ -77,11 +79,10 @@ const runGetPathToExtrudeForSegmentSelectionTest = async (
     code: string,
     expectedExtrudeSnippet: string
   ): CallExpression | PipeExpression | Error {
-    const extrudeRange: [number, number, boolean] = [
+    const extrudeRange = topLevelRange(
       code.indexOf(expectedExtrudeSnippet),
-      code.indexOf(expectedExtrudeSnippet) + expectedExtrudeSnippet.length,
-      true,
-    ]
+      code.indexOf(expectedExtrudeSnippet) + expectedExtrudeSnippet.length
+    )
     const expectedExtrudePath = getNodePathFromSourceRange(ast, extrudeRange)
     const expectedExtrudeNodeResult = getNodeFromPath<
       VariableDeclarator | CallExpression
@@ -112,11 +113,10 @@ const runGetPathToExtrudeForSegmentSelectionTest = async (
   const ast = assertParse(code)
 
   // selection
-  const segmentRange: [number, number, boolean] = [
+  const segmentRange = topLevelRange(
     code.indexOf(selectedSegmentSnippet),
-    code.indexOf(selectedSegmentSnippet) + selectedSegmentSnippet.length,
-    true,
-  ]
+    code.indexOf(selectedSegmentSnippet) + selectedSegmentSnippet.length
+  )
   const selection: Selection = {
     codeRef: codeRefFromRange(segmentRange, ast),
   }
@@ -260,12 +260,12 @@ const runModifyAstCloneWithEdgeTreatmentAndTag = async (
   const ast = assertParse(code)
 
   // selection
-  const segmentRanges: Array<[number, number, boolean]> = selectionSnippets.map(
-    (selectionSnippet) => [
-      code.indexOf(selectionSnippet),
-      code.indexOf(selectionSnippet) + selectionSnippet.length,
-      true,
-    ]
+  const segmentRanges: Array<SourceRange> = selectionSnippets.map(
+    (selectionSnippet) =>
+      topLevelRange(
+        code.indexOf(selectionSnippet),
+        code.indexOf(selectionSnippet) + selectionSnippet.length
+      )
   )
 
   // executeAst
@@ -596,11 +596,10 @@ extrude001 = extrude(-5, sketch001)
   it('should correctly identify getOppositeEdge and baseEdge edges', () => {
     const ast = assertParse(code)
     const lineOfInterest = `line([7.11, 3.48], %, $seg01)`
-    const range: [number, number, boolean] = [
+    const range = topLevelRange(
       code.indexOf(lineOfInterest),
-      code.indexOf(lineOfInterest) + lineOfInterest.length,
-      true,
-    ]
+      code.indexOf(lineOfInterest) + lineOfInterest.length
+    )
     const pathToNode = getNodePathFromSourceRange(ast, range)
     if (err(pathToNode)) return
     const callExp = getNodeFromPath<CallExpression>(
@@ -615,11 +614,10 @@ extrude001 = extrude(-5, sketch001)
   it('should correctly identify getPreviousAdjacentEdge edges', () => {
     const ast = assertParse(code)
     const lineOfInterest = `line([-6.37, 3.88], %, $seg02)`
-    const range: [number, number, boolean] = [
+    const range = topLevelRange(
       code.indexOf(lineOfInterest),
-      code.indexOf(lineOfInterest) + lineOfInterest.length,
-      true,
-    ]
+      code.indexOf(lineOfInterest) + lineOfInterest.length
+    )
     const pathToNode = getNodePathFromSourceRange(ast, range)
     if (err(pathToNode)) return
     const callExp = getNodeFromPath<CallExpression>(
@@ -634,11 +632,10 @@ extrude001 = extrude(-5, sketch001)
   it('should correctly identify no edges', () => {
     const ast = assertParse(code)
     const lineOfInterest = `line([-3.29, -13.85], %)`
-    const range: [number, number, boolean] = [
+    const range = topLevelRange(
       code.indexOf(lineOfInterest),
-      code.indexOf(lineOfInterest) + lineOfInterest.length,
-      true,
-    ]
+      code.indexOf(lineOfInterest) + lineOfInterest.length
+    )
     const pathToNode = getNodePathFromSourceRange(ast, range)
     if (err(pathToNode)) return
     const callExp = getNodeFromPath<CallExpression>(
@@ -660,13 +657,12 @@ describe('Testing button states', () => {
   ) => {
     const ast = assertParse(code)
 
-    const range: [number, number, boolean] = segmentSnippet
-      ? [
+    const range = segmentSnippet
+      ? topLevelRange(
           code.indexOf(segmentSnippet),
-          code.indexOf(segmentSnippet) + segmentSnippet.length,
-          true,
-        ]
-      : [ast.end, ast.end, true] // empty line in the end of the code
+          code.indexOf(segmentSnippet) + segmentSnippet.length
+        )
+      : topLevelRange(ast.end, ast.end) // empty line in the end of the code
 
     const selectionRanges: Selections = {
       graphSelections: [

src/lang/modifyAst/addEdgeTreatment.ts

@@ -1,4 +1,5 @@
 import {
+  ArtifactGraph,
   CallExpression,
   Expr,
   Identifier,
@@ -31,11 +32,7 @@ import {
 import { err, trap } from 'lib/trap'
 import { Selection, Selections } from 'lib/selections'
 import { KclCommandValue } from 'lib/commandTypes'
-import {
-  Artifact,
-  ArtifactGraph,
-  getSweepFromSuspectedPath,
-} from 'lang/std/artifactGraph'
+import { Artifact, getSweepFromSuspectedPath } from 'lang/std/artifactGraph'
 import {
   kclManager,
   engineCommandManager,

src/lang/modifyAst/addShell.ts

@@ -1,9 +1,8 @@
-import { ArtifactGraph } from 'lang/std/artifactGraph'
 import { Selections } from 'lib/selections'
 import { Expr } from 'wasm-lib/kcl/bindings/Expr'
 import { Program } from 'wasm-lib/kcl/bindings/Program'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
-import { PathToNode, VariableDeclarator } from 'lang/wasm'
+import { ArtifactGraph, PathToNode, VariableDeclarator } from 'lang/wasm'
 import {
   getPathToExtrudeForSegmentSelection,
   mutateAstWithTagForSketchSegment,

src/lang/queryAst.test.ts

@@ -4,6 +4,7 @@ import {
   initPromise,
   PathToNode,
   Identifier,
+  topLevelRange,
 } from './wasm'
 import {
   findAllPreviousVariables,
@@ -57,7 +58,7 @@ variableBelowShouldNotBeIncluded = 3
     const { variables, bodyPath, insertIndex } = findAllPreviousVariables(
       ast,
       execState.memory,
-      [rangeStart, rangeStart, true]
+      topLevelRange(rangeStart, rangeStart)
     )
     expect(variables).toEqual([
       { key: 'baseThick', value: 1 },
@@ -87,7 +88,10 @@ yo2 = hmm([identifierGuy + 5])`
   it('find a safe binaryExpression', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('100 + 100') + 2
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(true)
     expect(result.value?.type).toBe('BinaryExpression')
@@ -100,7 +104,10 @@ yo2 = hmm([identifierGuy + 5])`
   it('find a safe Identifier', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('abc')
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(true)
     expect(result.value?.type).toBe('Identifier')
@@ -109,7 +116,10 @@ yo2 = hmm([identifierGuy + 5])`
   it('find a safe CallExpression', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('def')
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(true)
     expect(result.value?.type).toBe('CallExpression')
@@ -122,7 +132,7 @@ yo2 = hmm([identifierGuy + 5])`
   it('find an UNsafe CallExpression, as it has a PipeSubstitution', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('ghi')
-    const range: [number, number, boolean] = [rangeStart, rangeStart, true]
+    const range = topLevelRange(rangeStart, rangeStart)
     const result = isNodeSafeToReplace(ast, range)
     if (err(result)) throw result
     expect(result.isSafe).toBe(false)
@@ -132,7 +142,10 @@ yo2 = hmm([identifierGuy + 5])`
   it('find an UNsafe Identifier, as it is a callee', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('ine([2.8,')
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(false)
     expect(result.value?.type).toBe('CallExpression')
@@ -143,7 +156,10 @@ yo2 = hmm([identifierGuy + 5])`
   it("find a safe BinaryExpression that's assigned to a variable", () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('5 + 6') + 1
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(true)
     expect(result.value?.type).toBe('BinaryExpression')
@@ -156,7 +172,10 @@ yo2 = hmm([identifierGuy + 5])`
   it('find a safe BinaryExpression that has a CallExpression within', () => {
     const ast = assertParse(code)
     const rangeStart = code.indexOf('jkl') + 1
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
     expect(result.isSafe).toBe(true)
     expect(result.value?.type).toBe('BinaryExpression')
@@ -173,7 +192,10 @@ yo2 = hmm([identifierGuy + 5])`
     const ast = assertParse(code)
 
     const rangeStart = code.indexOf('identifierGuy') + 1
-    const result = isNodeSafeToReplace(ast, [rangeStart, rangeStart, true])
+    const result = isNodeSafeToReplace(
+      ast,
+      topLevelRange(rangeStart, rangeStart)
+    )
     if (err(result)) throw result
 
     expect(result.isSafe).toBe(true)
@@ -222,11 +244,10 @@ describe('testing getNodePathFromSourceRange', () => {
     const sourceIndex = code.indexOf(searchLn) + searchLn.length
     const ast = assertParse(code)
 
-    const result = getNodePathFromSourceRange(ast, [
-      sourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const result = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(sourceIndex, sourceIndex)
+    )
     expect(result).toEqual([
       ['body', ''],
       [0, 'index'],
@@ -241,11 +262,10 @@ describe('testing getNodePathFromSourceRange', () => {
     const sourceIndex = code.indexOf(searchLn) + searchLn.length
     const ast = assertParse(code)
 
-    const result = getNodePathFromSourceRange(ast, [
-      sourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const result = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(sourceIndex, sourceIndex)
+    )
     const expected = [
       ['body', ''],
       [0, 'index'],
@@ -257,18 +277,16 @@ describe('testing getNodePathFromSourceRange', () => {
     expect(result).toEqual(expected)
     // expect similar result for start of line
     const startSourceIndex = code.indexOf(searchLn)
-    const startResult = getNodePathFromSourceRange(ast, [
-      startSourceIndex,
-      startSourceIndex,
-      true,
-    ])
+    const startResult = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(startSourceIndex, startSourceIndex)
+    )
     expect(startResult).toEqual([...expected, ['callee', 'CallExpression']])
     // expect similar result when whole line is selected
-    const selectWholeThing = getNodePathFromSourceRange(ast, [
-      startSourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const selectWholeThing = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(startSourceIndex, sourceIndex)
+    )
     expect(selectWholeThing).toEqual(expected)
   })
 
@@ -283,11 +301,10 @@ describe('testing getNodePathFromSourceRange', () => {
     const sourceIndex = code.indexOf(searchLn)
     const ast = assertParse(code)
 
-    const result = getNodePathFromSourceRange(ast, [
-      sourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const result = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(sourceIndex, sourceIndex)
+    )
     expect(result).toEqual([
       ['body', ''],
       [1, 'index'],
@@ -313,11 +330,10 @@ describe('testing getNodePathFromSourceRange', () => {
     const sourceIndex = code.indexOf(searchLn)
     const ast = assertParse(code)
 
-    const result = getNodePathFromSourceRange(ast, [
-      sourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const result = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(sourceIndex, sourceIndex)
+    )
     expect(result).toEqual([
       ['body', ''],
       [1, 'index'],
@@ -341,11 +357,10 @@ describe('testing getNodePathFromSourceRange', () => {
     const sourceIndex = code.indexOf(searchLn)
     const ast = assertParse(code)
 
-    const result = getNodePathFromSourceRange(ast, [
-      sourceIndex,
-      sourceIndex,
-      true,
-    ])
+    const result = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(sourceIndex, sourceIndex)
+    )
     expect(result).toEqual([
       ['body', ''],
       [0, 'index'],
@@ -375,7 +390,7 @@ part001 = startSketchAt([-1.41, 3.46])
     const result = hasExtrudeSketch({
       ast,
       selection: {
-        codeRef: codeRefFromRange([100, 101, true], ast),
+        codeRef: codeRefFromRange(topLevelRange(100, 101), ast),
       },
       programMemory: execState.memory,
     })
@@ -395,7 +410,7 @@ part001 = startSketchAt([-1.41, 3.46])
     const result = hasExtrudeSketch({
       ast,
       selection: {
-        codeRef: codeRefFromRange([100, 101, true], ast),
+        codeRef: codeRefFromRange(topLevelRange(100, 101), ast),
       },
       programMemory: execState.memory,
     })
@@ -409,7 +424,7 @@ part001 = startSketchAt([-1.41, 3.46])
     const result = hasExtrudeSketch({
       ast,
       selection: {
-        codeRef: codeRefFromRange([10, 11, true], ast),
+        codeRef: codeRefFromRange(topLevelRange(10, 11), ast),
       },
       programMemory: execState.memory,
     })
@@ -431,11 +446,10 @@ describe('Testing findUsesOfTagInPipe', () => {
     const lineOfInterest = `198.85], %, $seg01`
     const characterIndex =
       exampleCode.indexOf(lineOfInterest) + lineOfInterest.length
-    const pathToNode = getNodePathFromSourceRange(ast, [
-      characterIndex,
-      characterIndex,
-      true,
-    ])
+    const pathToNode = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(characterIndex, characterIndex)
+    )
     const result = findUsesOfTagInPipe(ast, pathToNode)
     expect(result).toHaveLength(2)
     result.forEach((range) => {
@@ -448,11 +462,10 @@ describe('Testing findUsesOfTagInPipe', () => {
     const lineOfInterest = `line([306.21, 198.82], %)`
     const characterIndex =
       exampleCode.indexOf(lineOfInterest) + lineOfInterest.length
-    const pathToNode = getNodePathFromSourceRange(ast, [
-      characterIndex,
-      characterIndex,
-      true,
-    ])
+    const pathToNode = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(characterIndex, characterIndex)
+    )
     const result = findUsesOfTagInPipe(ast, pathToNode)
     expect(result).toHaveLength(0)
   })
@@ -498,7 +511,10 @@ sketch003 = startSketchOn(extrude001, 'END')
       exampleCode.indexOf(lineOfInterest) + lineOfInterest.length
     const extruded = hasSketchPipeBeenExtruded(
       {
-        codeRef: codeRefFromRange([characterIndex, characterIndex, true], ast),
+        codeRef: codeRefFromRange(
+          topLevelRange(characterIndex, characterIndex),
+          ast
+        ),
       },
       ast
     )
@@ -511,7 +527,10 @@ sketch003 = startSketchOn(extrude001, 'END')
       exampleCode.indexOf(lineOfInterest) + lineOfInterest.length
     const extruded = hasSketchPipeBeenExtruded(
       {
-        codeRef: codeRefFromRange([characterIndex, characterIndex, true], ast),
+        codeRef: codeRefFromRange(
+          topLevelRange(characterIndex, characterIndex),
+          ast
+        ),
       },
       ast
     )
@@ -524,7 +543,10 @@ sketch003 = startSketchOn(extrude001, 'END')
       exampleCode.indexOf(lineOfInterest) + lineOfInterest.length
     const extruded = hasSketchPipeBeenExtruded(
       {
-        codeRef: codeRefFromRange([characterIndex, characterIndex, true], ast),
+        codeRef: codeRefFromRange(
+          topLevelRange(characterIndex, characterIndex),
+          ast
+        ),
       },
       ast
     )
@@ -651,11 +673,10 @@ myNestedVar = [
     })
 
     const literalIndex = code.indexOf(literalOfInterest)
-    const pathToNode2 = getNodePathFromSourceRange(ast, [
-      literalIndex + 2,
-      literalIndex + 2,
-      true,
-    ])
+    const pathToNode2 = getNodePathFromSourceRange(
+      ast,
+      topLevelRange(literalIndex + 2, literalIndex + 2)
+    )
     expect(pathToNode).toEqual(pathToNode2)
   })
 })

src/lang/queryAst.ts

@@ -2,6 +2,7 @@ import { ToolTip } from 'lang/langHelpers'
 import { Selection, Selections } from 'lib/selections'
 import {
   ArrayExpression,
+  ArtifactGraph,
   BinaryExpression,
   CallExpression,
   Expr,
@@ -16,8 +17,8 @@ import {
   sketchFromKclValue,
   sketchFromKclValueOptional,
   SourceRange,
-  sourceRangeFromRust,
   SyntaxType,
+  topLevelRange,
   VariableDeclaration,
   VariableDeclarator,
 } from './wasm'
@@ -32,7 +33,7 @@ import {
 import { err, Reason } from 'lib/trap'
 import { ImportStatement } from 'wasm-lib/kcl/bindings/ImportStatement'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
-import { ArtifactGraph, codeRefFromRange } from './std/artifactGraph'
+import { codeRefFromRange } from './std/artifactGraph'
 
 /**
  * Retrieves a node from a given path within a Program node structure, optionally stopping at a specified node type.
@@ -819,7 +820,7 @@ export function isLinesParallelAndConstrained(
     return {
       isParallelAndConstrained,
       selection: {
-        codeRef: codeRefFromRange(sourceRangeFromRust(prevSourceRange), ast),
+        codeRef: codeRefFromRange(prevSourceRange, ast),
         artifact: artifactGraph.get(prevSegment.__geoMeta.id),
       },
     }
@@ -937,7 +938,7 @@ export function findUsesOfTagInPipe(
       const tagArgValue =
         tagArg.type === 'TagDeclarator' ? String(tagArg.value) : tagArg.name
       if (tagArgValue === tag)
-        dependentRanges.push([node.start, node.end, true])
+        dependentRanges.push(topLevelRange(node.start, node.end))
     },
   })
   return dependentRanges

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

@@ -1,559 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`testing createArtifactGraph > code with an extrusion, fillet and sketch of face: > snapshot of the artifactGraph 1`] = `
-Map {
-  "UUID-0" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        12,
-        31,
-        true,
-      ],
-    },
-    "id": "UUID",
-    "pathIds": [
-      "UUID",
-    ],
-    "type": "plane",
-  },
-  "UUID-1" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        37,
-        64,
-        true,
-      ],
-    },
-    "id": "UUID",
-    "planeId": "UUID",
-    "segIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "solid2dId": "UUID",
-    "sweepId": "UUID",
-    "type": "path",
-  },
-  "UUID-2" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        70,
-        86,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-3" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        92,
-        119,
-        true,
-      ],
-    },
-    "edgeCutId": "UUID",
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-4" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        125,
-        150,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-5" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        156,
-        203,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-6" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        209,
-        217,
-        true,
-      ],
-    },
-    "edgeIds": [],
-    "id": "UUID",
-    "pathId": "UUID",
-    "type": "segment",
-  },
-  "UUID-7" => {
-    "id": "UUID",
-    "pathId": "UUID",
-    "type": "solid2D",
-  },
-  "UUID-8" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        231,
-        254,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "subType": "extrusion",
-    "surfaceIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "type": "sweep",
-  },
-  "UUID-9" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-10" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [
-      "UUID",
-    ],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-11" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-12" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-13" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "subType": "start",
-    "sweepId": "UUID",
-    "type": "cap",
-  },
-  "UUID-14" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "subType": "end",
-    "sweepId": "UUID",
-    "type": "cap",
-  },
-  "UUID-15" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-16" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-17" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-18" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-19" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-20" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-21" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-22" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-23" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        260,
-        299,
-        true,
-      ],
-    },
-    "consumedEdgeId": "UUID",
-    "edgeIds": [],
-    "id": "UUID",
-    "subType": "fillet",
-    "type": "edgeCut",
-  },
-  "UUID-24" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        350,
-        377,
-        true,
-      ],
-    },
-    "id": "UUID",
-    "planeId": "UUID",
-    "segIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "solid2dId": "UUID",
-    "sweepId": "UUID",
-    "type": "path",
-  },
-  "UUID-25" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        383,
-        398,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-26" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        404,
-        420,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-27" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        426,
-        473,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "surfaceId": "UUID",
-    "type": "segment",
-  },
-  "UUID-28" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        479,
-        487,
-        true,
-      ],
-    },
-    "edgeIds": [],
-    "id": "UUID",
-    "pathId": "UUID",
-    "type": "segment",
-  },
-  "UUID-29" => {
-    "id": "UUID",
-    "pathId": "UUID",
-    "type": "solid2D",
-  },
-  "UUID-30" => {
-    "codeRef": {
-      "pathToNode": [
-        [
-          "body",
-          "",
-        ],
-      ],
-      "range": [
-        501,
-        522,
-        true,
-      ],
-    },
-    "edgeIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "id": "UUID",
-    "pathId": "UUID",
-    "subType": "extrusion",
-    "surfaceIds": [
-      "UUID",
-      "UUID",
-      "UUID",
-      "UUID",
-    ],
-    "type": "sweep",
-  },
-  "UUID-31" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-32" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-33" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "segId": "UUID",
-    "sweepId": "UUID",
-    "type": "wall",
-  },
-  "UUID-34" => {
-    "edgeCutEdgeIds": [],
-    "id": "UUID",
-    "pathIds": [],
-    "subType": "end",
-    "sweepId": "UUID",
-    "type": "cap",
-  },
-  "UUID-35" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-36" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-37" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-38" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-39" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "opposite",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-  "UUID-40" => {
-    "id": "UUID",
-    "segId": "UUID",
-    "subType": "adjacent",
-    "sweepId": "UUID",
-    "type": "sweepEdge",
-  },
-}
-`;

src/lang/std/artifactGraph.test.ts

@@ -1,960 +0,0 @@
-import {
-  makeDefaultPlanes,
-  assertParse,
-  initPromise,
-  Program,
-  ArtifactCommand,
-  ExecState,
-} from 'lang/wasm'
-import { Models } from '@kittycad/lib'
-import {
-  ResponseMap,
-  createArtifactGraph,
-  filterArtifacts,
-  expandPlane,
-  expandPath,
-  expandSweep,
-  ArtifactGraph,
-  expandSegment,
-  getArtifactsToUpdate,
-} from './artifactGraph'
-import { err } from 'lib/trap'
-import { engineCommandManager, kclManager } from 'lib/singletons'
-import { VITE_KC_DEV_TOKEN } from 'env'
-import fsp from 'fs/promises'
-import fs from 'fs'
-import { chromium } from 'playwright'
-import * as d3 from 'd3-force'
-import path from 'path'
-import pixelmatch from 'pixelmatch'
-import { PNG } from 'pngjs'
-import { Node } from 'wasm-lib/kcl/bindings/Node'
-
-/*
-Note this is an integration test, these tests connect to our real dev server and make websocket commands.
-It's needed for testing the artifactGraph, as it is tied to the websocket commands.
-*/
-
-const pathStart = 'src/lang/std/artifactMapCache'
-const fullPath = `${pathStart}/artifactMapCache.json`
-
-const exampleCode1 = `sketch001 = startSketchOn('XY')
-  |> startProfileAt([-5, -5], %)
-  |> line([0, 10], %)
-  |> line([10.55, 0], %, $seg01)
-  |> line([0, -10], %, $seg02)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-extrude001 = extrude(-10, sketch001)
-  |> fillet({ radius: 5, tags: [seg01] }, %)
-sketch002 = startSketchOn(extrude001, seg02)
-  |> startProfileAt([-2, -6], %)
-  |> line([2, 3], %)
-  |> line([2, -3], %)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-extrude002 = extrude(5, sketch002)
-`
-
-const exampleCodeNo3D = `sketch003 = startSketchOn('YZ')
-  |> startProfileAt([5.82, 0], %)
-  |> angledLine([180, 11.54], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       8.21
-     ], %, $rectangleSegmentB001)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %, $rectangleSegmentC001)
-  |> lineTo([profileStartX(%), profileStartY(%)], %)
-  |> close(%)
-sketch004 = startSketchOn('-XZ')
-  |> startProfileAt([0, 14.36], %)
-  |> line([15.49, 0.05], %)
-  |> tangentialArcTo([0, 0], %)
-  |> tangentialArcTo([-6.8, 8.17], %)
-`
-
-const sketchOnFaceOnFaceEtc = `sketch001 = startSketchOn('XZ')
-|> startProfileAt([0, 0], %)
-|> line([4, 8], %)
-|> line([5, -8], %, $seg01)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)
-extrude001 = extrude(6, sketch001)
-sketch002 = startSketchOn(extrude001, seg01)
-|> startProfileAt([-0.5, 0.5], %)
-|> line([2, 5], %)
-|> line([2, -5], %)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)
-extrude002 = extrude(5, sketch002)
-sketch003 = startSketchOn(extrude002, 'END')
-|> startProfileAt([1, 1.5], %)
-|> line([0.5, 2], %, $seg02)
-|> line([1, -2], %)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)
-extrude003 = extrude(4, sketch003)
-sketch004 = startSketchOn(extrude003, seg02)
-|> startProfileAt([-3, 14], %)
-|> line([0.5, 1], %)
-|> line([0.5, -2], %)
-|> lineTo([profileStartX(%), profileStartY(%)], %)
-|> close(%)
-extrude004 = extrude(3, sketch004)
-`
-const exampleCodeOffsetPlanes = `
-offsetPlane001 = offsetPlane("XY", 20)
-offsetPlane002 = offsetPlane("XZ", -50)
-offsetPlane003 = offsetPlane("YZ", 10)
-
-sketch002 = startSketchOn(offsetPlane001)
-  |> startProfileAt([0, 0], %)
-  |> line([6.78, 15.01], %)
-`
-
-// add more code snippets here and use `getCommands` to get the artifactCommands and responseMap for more tests
-const codeToWriteCacheFor = {
-  exampleCode1,
-  sketchOnFaceOnFaceEtc,
-  exampleCodeNo3D,
-  exampleCodeOffsetPlanes,
-} as const
-
-type CodeKey = keyof typeof codeToWriteCacheFor
-
-type CacheShape = {
-  [key in CodeKey]: {
-    artifactCommands: ArtifactCommand[]
-    responseMap: ResponseMap
-    execStateArtifacts: ExecState['artifacts']
-  }
-}
-
-beforeAll(async () => {
-  await initPromise
-
-  // THESE TEST WILL FAIL without VITE_KC_DEV_TOKEN set in .env.development.local
-  await new Promise((resolve) => {
-    engineCommandManager.start({
-      // disableWebRTC: true,
-      token: VITE_KC_DEV_TOKEN,
-      // there does seem to be a minimum resolution, not sure what it is but 256 works ok.
-      width: 256,
-      height: 256,
-      makeDefaultPlanes: () => makeDefaultPlanes(engineCommandManager),
-      setMediaStream: () => {},
-      setIsStreamReady: () => {},
-      // eslint-disable-next-line @typescript-eslint/no-misused-promises
-      callbackOnEngineLiteConnect: async () => {
-        const cacheEntries = Object.entries(codeToWriteCacheFor) as [
-          CodeKey,
-          string
-        ][]
-        const cacheToWriteToFileTemp: Partial<CacheShape> = {}
-        for (const [codeKey, code] of cacheEntries) {
-          const ast = assertParse(code)
-          await kclManager.executeAst({ ast })
-
-          cacheToWriteToFileTemp[codeKey] = {
-            artifactCommands: kclManager.execState.artifactCommands,
-            responseMap: engineCommandManager.responseMap,
-            execStateArtifacts: kclManager.execState.artifacts,
-          }
-        }
-        const cache = JSON.stringify(cacheToWriteToFileTemp)
-
-        await fsp.mkdir(pathStart, { recursive: true })
-        await fsp.writeFile(fullPath, cache)
-        resolve(true)
-      },
-    })
-  })
-}, 20_000)
-
-afterAll(() => {
-  engineCommandManager.tearDown()
-})
-
-describe('testing createArtifactGraph', () => {
-  describe('code with offset planes and a sketch:', () => {
-    let ast: Node<Program>
-    let theMap: ReturnType<typeof createArtifactGraph>
-
-    it('setup', () => {
-      // putting this logic in here because describe blocks runs before beforeAll has finished
-      const {
-        artifactCommands,
-        responseMap,
-        ast: _ast,
-        execStateArtifacts,
-      } = getCommands('exampleCodeOffsetPlanes')
-      ast = _ast
-      theMap = createArtifactGraph({
-        artifactCommands,
-        responseMap,
-        ast,
-        execStateArtifacts,
-      })
-    })
-
-    it(`there should be one sketch`, () => {
-      const sketches = [...filterArtifacts({ types: ['path'] }, theMap)].map(
-        (path) => expandPath(path[1], theMap)
-      )
-      expect(sketches).toHaveLength(1)
-      sketches.forEach((path) => {
-        if (err(path)) throw path
-        expect(path.type).toBe('path')
-      })
-    })
-
-    it(`there should be three offsetPlanes`, () => {
-      const offsetPlanes = [
-        ...filterArtifacts({ types: ['plane'] }, theMap),
-      ].map((plane) => expandPlane(plane[1], theMap))
-      expect(offsetPlanes).toHaveLength(3)
-      offsetPlanes.forEach((path) => {
-        expect(path.type).toBe('plane')
-      })
-    })
-
-    it(`Only one offset plane should have a path`, () => {
-      const offsetPlanes = [
-        ...filterArtifacts({ types: ['plane'] }, theMap),
-      ].map((plane) => expandPlane(plane[1], theMap))
-      const offsetPlaneWithPaths = offsetPlanes.filter(
-        (plane) => plane.paths.length
-      )
-      expect(offsetPlaneWithPaths).toHaveLength(1)
-    })
-  })
-  describe('code with an extrusion, fillet and sketch of face:', () => {
-    let ast: Node<Program>
-    let theMap: ReturnType<typeof createArtifactGraph>
-    it('setup', () => {
-      // putting this logic in here because describe blocks runs before beforeAll has finished
-      const {
-        artifactCommands,
-        responseMap,
-        ast: _ast,
-        execStateArtifacts,
-      } = getCommands('exampleCode1')
-      ast = _ast
-      theMap = createArtifactGraph({
-        artifactCommands,
-        responseMap,
-        ast,
-        execStateArtifacts,
-      })
-    })
-
-    it('there should be two planes for the extrusion and the sketch on face', () => {
-      const planes = [...filterArtifacts({ types: ['plane'] }, theMap)].map(
-        (plane) => expandPlane(plane[1], theMap)
-      )
-      expect(planes).toHaveLength(1)
-      planes.forEach((path) => {
-        expect(path.type).toBe('plane')
-      })
-    })
-    it('there should be two paths for the extrusion and the sketch on face', () => {
-      const paths = [...filterArtifacts({ types: ['path'] }, theMap)].map(
-        (path) => expandPath(path[1], theMap)
-      )
-      expect(paths).toHaveLength(2)
-      paths.forEach((path) => {
-        if (err(path)) throw path
-        expect(path.type).toBe('path')
-      })
-    })
-
-    it('there should be two extrusions, for the original and the sketchOnFace, the first extrusion should have 6 sides of the cube', () => {
-      const extrusions = [...filterArtifacts({ types: ['sweep'] }, theMap)].map(
-        (extrusion) => expandSweep(extrusion[1], theMap)
-      )
-      expect(extrusions).toHaveLength(2)
-      extrusions.forEach((extrusion, index) => {
-        if (err(extrusion)) throw extrusion
-        expect(extrusion.type).toBe('sweep')
-        const firstExtrusionIsACubeIE6Sides = 6
-        // Each face of the triangular prism (5), but without the bottom cap.
-        // The engine doesn't generate that.
-        const secondExtrusionIsATriangularPrism = 4
-        expect(extrusion.surfaces.length).toBe(
-          !index
-            ? firstExtrusionIsACubeIE6Sides
-            : secondExtrusionIsATriangularPrism
-        )
-      })
-    })
-
-    it('there should be 5 + 4 segments,  4 (+close) from the first extrusion and 3 (+close) from the second', () => {
-      const segments = [...filterArtifacts({ types: ['segment'] }, theMap)].map(
-        (segment) => expandSegment(segment[1], theMap)
-      )
-      expect(segments).toHaveLength(9)
-    })
-
-    it('snapshot of the artifactGraph', () => {
-      const stableMap = new Map(
-        [...theMap].map(([, artifact], index): [string, any] => {
-          const stableValue: any = {}
-          Object.entries(artifact).forEach(([propName, value]) => {
-            if (
-              propName === 'type' ||
-              propName === 'codeRef' ||
-              propName === 'subType'
-            ) {
-              stableValue[propName] = value
-              return
-            }
-            if (Array.isArray(value))
-              stableValue[propName] = value.map(() => 'UUID')
-            if (typeof value === 'string' && value)
-              stableValue[propName] = 'UUID'
-          })
-          return [`UUID-${index}`, stableValue]
-        })
-      )
-      expect(stableMap).toMatchSnapshot()
-    })
-
-    it('screenshot graph', async () => {
-      // Ostensibly this takes a screen shot of the graph of the artifactGraph
-      // but it's it also tests that all of the id links are correct because if one
-      // of the edges refers to a non-existent node, the graph will throw.
-      // further more we can check that each edge is bi-directional, if it's not
-      // by checking the arrow heads going both ways, on the graph.
-      await GraphTheGraph(theMap, 2000, 2000, 'exampleCode1.png')
-    }, 20000)
-  })
-
-  describe(`code with sketches but no extrusions or other 3D elements`, () => {
-    let ast: Node<Program>
-    let theMap: ReturnType<typeof createArtifactGraph>
-    it(`setup`, () => {
-      // putting this logic in here because describe blocks runs before beforeAll has finished
-      const {
-        artifactCommands,
-        responseMap,
-        ast: _ast,
-        execStateArtifacts,
-      } = getCommands('exampleCodeNo3D')
-      ast = _ast
-      theMap = createArtifactGraph({
-        artifactCommands,
-        responseMap,
-        ast,
-        execStateArtifacts,
-      })
-    })
-
-    it('there should be two planes, one for each sketch path', () => {
-      const planes = [...filterArtifacts({ types: ['plane'] }, theMap)].map(
-        (plane) => expandPlane(plane[1], theMap)
-      )
-      expect(planes).toHaveLength(2)
-      planes.forEach((path) => {
-        expect(path.type).toBe('plane')
-      })
-    })
-    it('there should be two paths, one on each plane', () => {
-      const paths = [...filterArtifacts({ types: ['path'] }, theMap)].map(
-        (path) => expandPath(path[1], theMap)
-      )
-      expect(paths).toHaveLength(2)
-      paths.forEach((path) => {
-        if (err(path)) throw path
-        expect(path.type).toBe('path')
-      })
-    })
-
-    it(`there should be 1 solid2D, just for the first closed path`, () => {
-      const solid2Ds = [...filterArtifacts({ types: ['solid2D'] }, theMap)]
-      expect(solid2Ds).toHaveLength(1)
-    })
-
-    it('there should be no extrusions', () => {
-      const extrusions = [...filterArtifacts({ types: ['sweep'] }, theMap)].map(
-        (extrusion) => expandSweep(extrusion[1], theMap)
-      )
-      expect(extrusions).toHaveLength(0)
-    })
-
-    it('there should be 8 segments, 4 + 1 (close) from the first sketch and 3 from the second', () => {
-      const segments = [...filterArtifacts({ types: ['segment'] }, theMap)].map(
-        (segment) => expandSegment(segment[1], theMap)
-      )
-      expect(segments).toHaveLength(8)
-    })
-
-    it('screenshot graph', async () => {
-      // Ostensibly this takes a screen shot of the graph of the artifactGraph
-      // but it's it also tests that all of the id links are correct because if one
-      // of the edges refers to a non-existent node, the graph will throw.
-      // further more we can check that each edge is bi-directional, if it's not
-      // by checking the arrow heads going both ways, on the graph.
-      await GraphTheGraph(theMap, 2000, 2000, 'exampleCodeNo3D.png')
-    }, 20000)
-  })
-})
-
-describe('capture graph of sketchOnFaceOnFace...', () => {
-  describe('code with an extrusion, fillet and sketch of face:', () => {
-    let ast: Node<Program>
-    let theMap: ReturnType<typeof createArtifactGraph>
-    it('setup', async () => {
-      // putting this logic in here because describe blocks runs before beforeAll has finished
-      const {
-        artifactCommands,
-        responseMap,
-        ast: _ast,
-        execStateArtifacts,
-      } = getCommands('sketchOnFaceOnFaceEtc')
-      ast = _ast
-      theMap = createArtifactGraph({
-        artifactCommands,
-        responseMap,
-        ast,
-        execStateArtifacts,
-      })
-
-      // Ostensibly this takes a screen shot of the graph of the artifactGraph
-      // but it's it also tests that all of the id links are correct because if one
-      // of the edges refers to a non-existent node, the graph will throw.
-      // further more we can check that each edge is bi-directional, if it's not
-      // by checking the arrow heads going both ways, on the graph.
-      await GraphTheGraph(theMap, 3000, 3000, 'sketchOnFaceOnFaceEtc.png')
-    }, 20000)
-  })
-})
-
-function getCommands(
-  codeKey: CodeKey
-): CacheShape[CodeKey] & { ast: Node<Program> } {
-  const ast = assertParse(codeKey)
-  const file = fs.readFileSync(fullPath, 'utf-8')
-  const parsed: CacheShape = JSON.parse(file)
-  // these either already exist from the last run, or were created in
-  const artifactCommands = parsed[codeKey].artifactCommands
-  const responseMap = parsed[codeKey].responseMap
-  const execStateArtifacts = parsed[codeKey].execStateArtifacts
-  return {
-    artifactCommands,
-    responseMap,
-    ast,
-    execStateArtifacts,
-  }
-}
-
-async function GraphTheGraph(
-  theMap: ArtifactGraph,
-  sizeX: number,
-  sizeY: number,
-  imageName: string
-) {
-  const nodes: Array<{ id: string; label: string }> = []
-  const edges: Array<{ source: string; target: string; label: string }> = []
-  let index = 0
-  for (const [commandId, artifact] of theMap) {
-    nodes.push({
-      id: commandId,
-      label: `${artifact.type}-${index++}`,
-    })
-    Object.entries(artifact).forEach(([propName, value]) => {
-      if (
-        propName === 'type' ||
-        propName === 'codeRef' ||
-        propName === 'subType' ||
-        propName === 'id'
-      )
-        return
-      if (Array.isArray(value))
-        value.forEach((v) => {
-          v && edges.push({ source: commandId, target: v, label: propName })
-        })
-      if (typeof value === 'string' && value)
-        edges.push({ source: commandId, target: value, label: propName })
-    })
-  }
-
-  // Create a force simulation to calculate node positions
-  const simulation = d3
-    .forceSimulation(nodes as any)
-    .force(
-      'link',
-      d3
-        .forceLink(edges)
-        .id((d: any) => d.id)
-        .distance(100)
-    )
-    .force('charge', d3.forceManyBody().strength(-300))
-    .force('center', d3.forceCenter(300, 200))
-    .stop()
-
-  // Run the simulation
-  for (let i = 0; i < 300; ++i) simulation.tick()
-
-  // Create traces for Plotly
-  const nodeTrace = {
-    x: nodes.map((node: any) => node.x),
-    y: nodes.map((node: any) => node.y),
-    text: nodes.map((node) => node.label), // Use the custom label
-    mode: 'markers+text',
-    type: 'scatter',
-    marker: { size: 20, color: 'gray' }, // Nodes in gray
-    textfont: { size: 14, color: 'black' }, // Labels in black
-    textposition: 'top center', // Position text on top
-  }
-
-  const edgeTrace = {
-    x: [],
-    y: [],
-    mode: 'lines',
-    type: 'scatter',
-    line: { width: 2, color: 'lightgray' }, // Edges in light gray
-  }
-
-  const annotations: any[] = []
-
-  edges.forEach((edge) => {
-    const sourceNode = nodes.find(
-      (node: any) => node.id === (edge as any).source.id
-    )
-    const targetNode = nodes.find(
-      (node: any) => node.id === (edge as any).target.id
-    )
-
-    // Check if nodes are found
-    if (!sourceNode || !targetNode) {
-      throw new Error(
-        // @ts-ignore
-        `Node not found: ${!sourceNode ? edge.source.id : edge.target.id}`
-      )
-    }
-
-    // @ts-ignore
-    edgeTrace.x.push(sourceNode.x, targetNode.x, null)
-    // @ts-ignore
-    edgeTrace.y.push(sourceNode.y, targetNode.y, null)
-
-    // Calculate offset for arrowhead
-    const offsetFactor = 0.9 // Adjust this factor to control the offset distance
-    // @ts-ignore
-    const offsetX = (targetNode.x - sourceNode.x) * offsetFactor
-    // @ts-ignore
-    const offsetY = (targetNode.y - sourceNode.y) * offsetFactor
-
-    // Add arrowhead annotation with offset
-    annotations.push({
-      // @ts-ignore
-      ax: sourceNode.x,
-      // @ts-ignore
-      ay: sourceNode.y,
-      // @ts-ignore
-      x: targetNode.x - offsetX,
-      // @ts-ignore
-      y: targetNode.y - offsetY,
-      xref: 'x',
-      yref: 'y',
-      axref: 'x',
-      ayref: 'y',
-      showarrow: true,
-      arrowhead: 2,
-      arrowsize: 1,
-      arrowwidth: 2,
-      arrowcolor: 'darkgray', // Arrowheads in dark gray
-    })
-
-    // Add edge label annotation closer to the edge tail (25% of the length)
-    // @ts-ignore
-    const labelX = sourceNode.x * 0.75 + targetNode.x * 0.25
-    // @ts-ignore
-    const labelY = sourceNode.y * 0.75 + targetNode.y * 0.25
-    annotations.push({
-      x: labelX,
-      y: labelY,
-      xref: 'x',
-      yref: 'y',
-      text: edge.label,
-      showarrow: false,
-      font: { size: 12, color: 'black' }, // Edge labels in black
-      align: 'center',
-    })
-  })
-
-  const data = [edgeTrace, nodeTrace]
-
-  const layout = {
-    // title: 'Force-Directed Graph with Nodes and Edges',
-    xaxis: { showgrid: false, zeroline: false, showticklabels: false },
-    yaxis: { showgrid: false, zeroline: false, showticklabels: false },
-    showlegend: false,
-    annotations: annotations,
-  }
-
-  // Export to PNG using Playwright
-  const browser = await chromium.launch()
-  const page = await browser.newPage()
-  await page.setContent(`
-    <html>
-      <head>
-        <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
-      </head>
-      <body>
-        <div id="plotly-graph" style="width:${sizeX}px;height:${sizeY}px;"></div>
-        <script>
-          Plotly.newPlot('plotly-graph', ${JSON.stringify(
-            data
-          )}, ${JSON.stringify(layout)})
-        </script>
-      </body>
-    </html>
-  `)
-  await page.waitForSelector('#plotly-graph')
-  const element = await page.$('#plotly-graph')
-
-  // @ts-ignore
-  await element.screenshot({
-    path: `./e2e/playwright/temp3.png`,
-  })
-
-  await browser.close()
-
-  const originalImgPath = path.resolve(
-    `./src/lang/std/artifactMapGraphs/${imageName}`
-  )
-  // chop the top 30 pixels off the image
-  const originalImgExists = fs.existsSync(originalImgPath)
-  const originalImg = originalImgExists
-    ? PNG.sync.read(fs.readFileSync(originalImgPath))
-    : null
-  // const img1Data = new Uint8Array(img1.data)
-  // const img1DataChopped = img1Data.slice(30 * img1.width * 4)
-  // img1.data = Buffer.from(img1DataChopped)
-
-  const newImagePath = path.resolve('./e2e/playwright/temp3.png')
-  const newImage = PNG.sync.read(fs.readFileSync(newImagePath))
-  const newImageData = new Uint8Array(newImage.data)
-  const newImageDataChopped = newImageData.slice(30 * newImage.width * 4)
-  newImage.data = Buffer.from(newImageDataChopped)
-
-  const { width, height } = originalImg ?? newImage
-  const diff = new PNG({ width, height })
-
-  const imageSizeDifferent = originalImg?.data.length !== newImage.data.length
-  let numDiffPixels = 0
-  if (!imageSizeDifferent) {
-    numDiffPixels = pixelmatch(
-      originalImg.data,
-      newImage.data,
-      diff.data,
-      width,
-      height,
-      {
-        threshold: 0.1,
-      }
-    )
-  }
-
-  if (numDiffPixels > 10 || imageSizeDifferent) {
-    console.warn('numDiffPixels', numDiffPixels)
-    // write file out to final place
-    fs.writeFileSync(
-      `src/lang/std/artifactMapGraphs/${imageName}`,
-      PNG.sync.write(newImage)
-    )
-  }
-}
-
-describe('testing getArtifactsToUpdate', () => {
-  it('should return an array of artifacts to update', () => {
-    const { artifactCommands, responseMap, ast, execStateArtifacts } =
-      getCommands('exampleCode1')
-    const map = createArtifactGraph({
-      artifactCommands,
-      responseMap,
-      ast,
-      execStateArtifacts,
-    })
-    const getArtifact = (id: string) => map.get(id)
-    const currentPlaneId = 'UUID-1'
-    const getUpdateObjects = (type: Models['ModelingCmd_type']['type']) => {
-      const artifactCommand = artifactCommands.find(
-        (a) => a.command.type === type
-      )
-      if (!artifactCommand) {
-        throw new Error(`No artifactCommand found for ${type}`)
-      }
-      const artifactsToUpdate = getArtifactsToUpdate({
-        artifactCommand,
-        responseMap,
-        getArtifact,
-        currentPlaneId,
-        ast,
-        execStateArtifacts,
-      })
-      return artifactsToUpdate.map(({ artifact }) => artifact)
-    }
-    expect(getUpdateObjects('start_path')).toEqual([
-      {
-        type: 'path',
-        segIds: [],
-        id: expect.any(String),
-        planeId: 'UUID-1',
-        sweepId: '',
-        codeRef: {
-          pathToNode: [['body', '']],
-          range: [37, 64, true],
-        },
-      },
-    ])
-    expect(getUpdateObjects('extrude')).toEqual([
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        pathId: expect.any(String),
-        id: expect.any(String),
-        surfaceIds: [],
-        edgeIds: [],
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'path',
-        id: expect.any(String),
-        segIds: expect.any(Array),
-        planeId: expect.any(String),
-        sweepId: expect.any(String),
-        codeRef: {
-          range: [37, 64, true],
-          pathToNode: [['body', '']],
-        },
-        solid2dId: expect.any(String),
-      },
-    ])
-    expect(getUpdateObjects('extend_path')).toEqual([
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: '',
-        edgeIds: [],
-        codeRef: {
-          range: [70, 86, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'path',
-        id: expect.any(String),
-        segIds: expect.any(Array),
-        planeId: expect.any(String),
-        sweepId: expect.any(String),
-        codeRef: {
-          range: [37, 64, true],
-          pathToNode: [['body', '']],
-        },
-        solid2dId: expect.any(String),
-      },
-    ])
-    expect(getUpdateObjects('solid3d_fillet_edge')).toEqual([
-      {
-        type: 'edgeCut',
-        subType: 'fillet',
-        id: expect.any(String),
-        consumedEdgeId: expect.any(String),
-        edgeIds: [],
-        surfaceId: '',
-        codeRef: {
-          range: [260, 299, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: expect.any(String),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [92, 119, true],
-          pathToNode: [['body', '']],
-        },
-        edgeCutId: expect.any(String),
-      },
-    ])
-    expect(getUpdateObjects('solid3d_get_extrusion_face_info')).toEqual([
-      {
-        type: 'wall',
-        id: expect.any(String),
-        segId: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: expect.any(String),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [156, 203, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'wall',
-        id: expect.any(String),
-        segId: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: expect.any(String),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [125, 150, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'wall',
-        id: expect.any(String),
-        segId: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: expect.any(String),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [92, 119, true],
-          pathToNode: [['body', '']],
-        },
-        edgeCutId: expect.any(String),
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'wall',
-        id: expect.any(String),
-        segId: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'segment',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceId: expect.any(String),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [70, 86, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'cap',
-        subType: 'start',
-        id: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-      {
-        type: 'cap',
-        subType: 'end',
-        id: expect.any(String),
-        edgeCutEdgeIds: [],
-        sweepId: expect.any(String),
-        pathIds: [],
-      },
-      {
-        type: 'sweep',
-        subType: 'extrusion',
-        id: expect.any(String),
-        pathId: expect.any(String),
-        surfaceIds: expect.any(Array),
-        edgeIds: expect.any(Array),
-        codeRef: {
-          range: [231, 254, true],
-          pathToNode: [['body', '']],
-        },
-      },
-    ])
-  })
-})

src/lang/std/artifactGraph.ts

@@ -1,17 +1,25 @@
 import {
-  ArtifactCommand,
-  ExecState,
+  Artifact,
+  ArtifactGraph,
+  ArtifactId,
   PathToNode,
   Program,
   SourceRange,
-  sourceRangeFromRust,
+  PathArtifact,
+  PlaneArtifact,
+  WallArtifact,
+  SegmentArtifact,
+  Solid2dArtifact as Solid2D,
+  SweepArtifact,
+  SweepEdge,
+  CapArtifact,
+  EdgeCut,
 } from 'lang/wasm'
 import { Models } from '@kittycad/lib'
 import { getNodePathFromSourceRange } from 'lang/queryAst'
 import { err } from 'lib/trap'
-import { Node } from 'wasm-lib/kcl/bindings/Node'
 
-export type ArtifactId = string
+export type { Artifact, ArtifactId, SegmentArtifact } from 'lang/wasm'
 
 interface BaseArtifact {
   id: ArtifactId
@@ -22,30 +30,12 @@ export interface CodeRef {
   pathToNode: PathToNode
 }
 
-export interface PlaneArtifact extends BaseArtifact {
-  type: 'plane'
-  pathIds: Array<ArtifactId>
-  codeRef: CodeRef
-}
 export interface PlaneArtifactRich extends BaseArtifact {
   type: 'plane'
   paths: Array<PathArtifact>
   codeRef: CodeRef
 }
 
-export interface PathArtifact extends BaseArtifact {
-  type: 'path'
-  planeId: ArtifactId
-  segIds: Array<ArtifactId>
-  sweepId: ArtifactId
-  solid2dId?: ArtifactId
-  codeRef: CodeRef
-}
-
-interface solid2D extends BaseArtifact {
-  type: 'solid2D'
-  pathId: ArtifactId
-}
 export interface PathArtifactRich extends BaseArtifact {
   type: 'path'
   /** A path must always lie on a plane */
@@ -53,36 +43,19 @@ export interface PathArtifactRich extends BaseArtifact {
   /** A path must always contain 0 or more segments */
   segments: Array<SegmentArtifact>
   /** A path may not result in a sweep artifact */
-  sweep?: SweepArtifact
+  sweep: SweepArtifact | null
   codeRef: CodeRef
 }
 
-export interface SegmentArtifact extends BaseArtifact {
-  type: 'segment'
-  pathId: ArtifactId
-  surfaceId: ArtifactId
-  edgeIds: Array<ArtifactId>
-  edgeCutId?: ArtifactId
-  codeRef: CodeRef
-}
 interface SegmentArtifactRich extends BaseArtifact {
   type: 'segment'
   path: PathArtifact
-  surf: WallArtifact
+  surf?: WallArtifact
   edges: Array<SweepEdge>
   edgeCut?: EdgeCut
   codeRef: CodeRef
 }
 
-/** A Sweep is a more generic term for extrude, revolve, loft and sweep*/
-interface SweepArtifact extends BaseArtifact {
-  type: 'sweep'
-  subType: 'extrusion' | 'revolve' | 'loft' | 'sweep'
-  pathId: string
-  surfaceIds: Array<string>
-  edgeIds: Array<string>
-  codeRef: CodeRef
-}
 interface SweepArtifactRich extends BaseArtifact {
   type: 'sweep'
   subType: 'extrusion' | 'revolve' | 'loft' | 'sweep'
@@ -92,58 +65,6 @@ interface SweepArtifactRich extends BaseArtifact {
   codeRef: CodeRef
 }
 
-interface WallArtifact extends BaseArtifact {
-  type: 'wall'
-  segId: ArtifactId
-  edgeCutEdgeIds: Array<ArtifactId>
-  sweepId: ArtifactId
-  pathIds: Array<ArtifactId>
-}
-interface CapArtifact extends BaseArtifact {
-  type: 'cap'
-  subType: 'start' | 'end'
-  edgeCutEdgeIds: Array<ArtifactId>
-  sweepId: ArtifactId
-  pathIds: Array<ArtifactId>
-}
-
-interface SweepEdge extends BaseArtifact {
-  type: 'sweepEdge'
-  segId: ArtifactId
-  sweepId: ArtifactId
-  subType: 'opposite' | 'adjacent'
-}
-
-/** A edgeCut is a more generic term for both fillet or chamfer */
-interface EdgeCut extends BaseArtifact {
-  type: 'edgeCut'
-  subType: 'fillet' | 'chamfer'
-  consumedEdgeId: ArtifactId
-  edgeIds: Array<ArtifactId>
-  surfaceId: ArtifactId
-  codeRef: CodeRef
-}
-
-interface EdgeCutEdge extends BaseArtifact {
-  type: 'edgeCutEdge'
-  edgeCutId: ArtifactId
-  surfaceId: ArtifactId
-}
-
-export type Artifact =
-  | PlaneArtifact
-  | PathArtifact
-  | SegmentArtifact
-  | SweepArtifact
-  | WallArtifact
-  | CapArtifact
-  | SweepEdge
-  | EdgeCut
-  | EdgeCutEdge
-  | solid2D
-
-export type ArtifactGraph = Map<ArtifactId, Artifact>
-
 export type EngineCommand = Models['WebSocketRequest_type']
 
 type OkWebSocketResponseData = Models['OkWebSocketResponseData_type']
@@ -152,430 +73,6 @@ export interface ResponseMap {
   [commandId: string]: OkWebSocketResponseData
 }
 
-/** Creates a graph of artifacts from a list of ordered commands and their responses
- * muting the Map should happen entirely this function, other functions called within
- * should return data on how to update the map, and not do so directly.
- */
-export function createArtifactGraph({
-  artifactCommands,
-  responseMap,
-  ast,
-  execStateArtifacts,
-}: {
-  artifactCommands: Array<ArtifactCommand>
-  responseMap: ResponseMap
-  ast: Node<Program>
-  execStateArtifacts: ExecState['artifacts']
-}) {
-  const myMap = new Map<ArtifactId, Artifact>()
-
-  /** see docstring for {@link getArtifactsToUpdate} as to why this is needed */
-  let currentPlaneId = ''
-
-  for (const artifactCommand of artifactCommands) {
-    if (artifactCommand.command.type === 'enable_sketch_mode') {
-      currentPlaneId = artifactCommand.command.entity_id
-    }
-    if (artifactCommand.command.type === 'sketch_mode_disable') {
-      currentPlaneId = ''
-    }
-    const artifactsToUpdate = getArtifactsToUpdate({
-      artifactCommand,
-      responseMap,
-      getArtifact: (id: ArtifactId) => myMap.get(id),
-      currentPlaneId,
-      ast,
-      execStateArtifacts,
-    })
-    artifactsToUpdate.forEach(({ id, artifact }) => {
-      const mergedArtifact = mergeArtifacts(myMap.get(id), artifact)
-      myMap.set(id, mergedArtifact)
-    })
-  }
-  return myMap
-}
-
-/** Merges two artifacts, since our artifacts only contain strings and arrays of string for values we coerce that
- * but maybe types can be improved here.
- */
-function mergeArtifacts(
-  oldArtifact: Artifact | undefined,
-  newArtifact: Artifact
-): Artifact {
-  // only has string and array of strings
-  interface GenericArtifact {
-    [key: string]: string | Array<string>
-  }
-  if (!oldArtifact) return newArtifact
-  // merging artifacts of different types should never happen, but if it does, just return the new artifact
-  if (oldArtifact.type !== newArtifact.type) return newArtifact
-  const _oldArtifact = oldArtifact as any as GenericArtifact
-  const mergedArtifact = { ...oldArtifact, ...newArtifact } as GenericArtifact
-  Object.entries(newArtifact as any as GenericArtifact).forEach(
-    ([propName, value]) => {
-      const otherValue = _oldArtifact[propName]
-      if (Array.isArray(value) && Array.isArray(otherValue)) {
-        mergedArtifact[propName] = [...new Set([...otherValue, ...value])]
-      }
-    }
-  )
-  return mergedArtifact as any as Artifact
-}
-
-/**
- * Processes a single command and it's response in order to populate the artifact map
- * It does not mutate the map directly, but returns an array of artifacts to update
- *
- * @param currentPlaneId is only needed for `start_path` commands because this command does not have a pathId
- * instead it relies on the id used with the `enable_sketch_mode` command, so this much be kept track of
- * outside of this function. It would be good to update the `start_path` command to include the planeId so we
- * can remove this.
- */
-export function getArtifactsToUpdate({
-  artifactCommand,
-  getArtifact,
-  responseMap,
-  currentPlaneId,
-  ast,
-  execStateArtifacts,
-}: {
-  artifactCommand: ArtifactCommand
-  responseMap: ResponseMap
-  /** Passing in a getter because we don't wan this function to update the map directly */
-  getArtifact: (id: ArtifactId) => Artifact | undefined
-  currentPlaneId: ArtifactId
-  ast: Node<Program>
-  execStateArtifacts: ExecState['artifacts']
-}): Array<{
-  id: ArtifactId
-  artifact: Artifact
-}> {
-  const range = sourceRangeFromRust(artifactCommand.range)
-  const pathToNode = getNodePathFromSourceRange(ast, range)
-
-  const id = artifactCommand.cmdId
-  const response = responseMap[id]
-  const cmd = artifactCommand.command
-  const returnArr: ReturnType<typeof getArtifactsToUpdate> = []
-  if (!response) return returnArr
-  if (cmd.type === 'make_plane' && range[1] !== 0) {
-    // If we're calling `make_plane` and the code range doesn't end at `0`
-    // it's not a default plane, but a custom one from the offsetPlane standard library function
-    return [
-      {
-        id,
-        artifact: {
-          type: 'plane',
-          id,
-          pathIds: [],
-          codeRef: { range, pathToNode },
-        },
-      },
-    ]
-  } else if (cmd.type === 'enable_sketch_mode') {
-    const plane = getArtifact(currentPlaneId)
-    const pathIds = plane?.type === 'plane' ? plane?.pathIds : []
-    const codeRef =
-      plane?.type === 'plane' ? plane?.codeRef : { range, pathToNode }
-    const existingPlane = getArtifact(currentPlaneId)
-    if (existingPlane?.type === 'wall') {
-      return [
-        {
-          id: currentPlaneId,
-          artifact: {
-            type: 'wall',
-            id: currentPlaneId,
-            segId: existingPlane.segId,
-            edgeCutEdgeIds: existingPlane.edgeCutEdgeIds,
-            sweepId: existingPlane.sweepId,
-            pathIds: existingPlane.pathIds,
-          },
-        },
-      ]
-    } else {
-      return [
-        {
-          id: currentPlaneId,
-          artifact: { type: 'plane', id: currentPlaneId, pathIds, codeRef },
-        },
-      ]
-    }
-  } else if (cmd.type === 'start_path') {
-    returnArr.push({
-      id,
-      artifact: {
-        type: 'path',
-        id,
-        segIds: [],
-        planeId: currentPlaneId,
-        sweepId: '',
-        codeRef: { range, pathToNode },
-      },
-    })
-    const plane = getArtifact(currentPlaneId)
-    const codeRef =
-      plane?.type === 'plane' ? plane?.codeRef : { range, pathToNode }
-    if (plane?.type === 'plane') {
-      returnArr.push({
-        id: currentPlaneId,
-        artifact: { type: 'plane', id: currentPlaneId, pathIds: [id], codeRef },
-      })
-    }
-    if (plane?.type === 'wall') {
-      returnArr.push({
-        id: currentPlaneId,
-        artifact: {
-          type: 'wall',
-          id: currentPlaneId,
-          segId: plane.segId,
-          edgeCutEdgeIds: plane.edgeCutEdgeIds,
-          sweepId: plane.sweepId,
-          pathIds: [id],
-        },
-      })
-    }
-    return returnArr
-  } else if (cmd.type === 'extend_path' || cmd.type === 'close_path') {
-    const pathId = cmd.type === 'extend_path' ? cmd.path : cmd.path_id
-    returnArr.push({
-      id,
-      artifact: {
-        type: 'segment',
-        id,
-        pathId,
-        surfaceId: '',
-        edgeIds: [],
-        codeRef: { range, pathToNode },
-      },
-    })
-    const path = getArtifact(pathId)
-    if (path?.type === 'path')
-      returnArr.push({
-        id: pathId,
-        artifact: { ...path, segIds: [id] },
-      })
-    if (
-      response?.type === 'modeling' &&
-      response.data.modeling_response.type === 'close_path'
-    ) {
-      returnArr.push({
-        id: response.data.modeling_response.data.face_id,
-        artifact: {
-          type: 'solid2D',
-          id: response.data.modeling_response.data.face_id,
-          pathId,
-        },
-      })
-      const path = getArtifact(pathId)
-      if (path?.type === 'path')
-        returnArr.push({
-          id: pathId,
-          artifact: {
-            ...path,
-            solid2dId: response.data.modeling_response.data.face_id,
-          },
-        })
-    }
-    return returnArr
-  } else if (
-    cmd.type === 'extrude' ||
-    cmd.type === 'revolve' ||
-    cmd.type === 'sweep'
-  ) {
-    const subType = cmd.type === 'extrude' ? 'extrusion' : cmd.type
-    returnArr.push({
-      id,
-      artifact: {
-        type: 'sweep',
-        subType: subType,
-        id,
-        pathId: cmd.target,
-        surfaceIds: [],
-        edgeIds: [],
-        codeRef: { range, pathToNode },
-      },
-    })
-    const path = getArtifact(cmd.target)
-    if (path?.type === 'path')
-      returnArr.push({
-        id: cmd.target,
-        artifact: { ...path, sweepId: id },
-      })
-    return returnArr
-  } else if (
-    cmd.type === 'loft' &&
-    response.type === 'modeling' &&
-    response.data.modeling_response.type === 'loft'
-  ) {
-    returnArr.push({
-      id,
-      artifact: {
-        type: 'sweep',
-        subType: 'loft',
-        id,
-        // TODO: make sure to revisit this choice, don't think it matters for now
-        pathId: cmd.section_ids[0],
-        surfaceIds: [],
-        edgeIds: [],
-        codeRef: { range, pathToNode },
-      },
-    })
-    for (const sectionId of cmd.section_ids) {
-      const path = getArtifact(sectionId)
-      if (path?.type === 'path')
-        returnArr.push({
-          id: sectionId,
-          artifact: { ...path, sweepId: id },
-        })
-    }
-    return returnArr
-  } else if (
-    cmd.type === 'solid3d_get_extrusion_face_info' &&
-    response?.type === 'modeling' &&
-    response.data.modeling_response.type === 'solid3d_get_extrusion_face_info'
-  ) {
-    let lastPath: PathArtifact
-    response.data.modeling_response.data.faces.forEach(
-      ({ curve_id, cap, face_id }) => {
-        if (cap === 'none' && curve_id && face_id) {
-          const seg = getArtifact(curve_id)
-          if (seg?.type !== 'segment') return
-          const path = getArtifact(seg.pathId)
-          if (path?.type === 'path' && seg?.type === 'segment') {
-            lastPath = path
-            returnArr.push({
-              id: face_id,
-              artifact: {
-                type: 'wall',
-                id: face_id,
-                segId: curve_id,
-                edgeCutEdgeIds: [],
-                sweepId: path.sweepId,
-                pathIds: [],
-              },
-            })
-            returnArr.push({
-              id: curve_id,
-              artifact: { ...seg, surfaceId: face_id },
-            })
-            const sweep = getArtifact(path.sweepId)
-            if (sweep?.type === 'sweep') {
-              returnArr.push({
-                id: path.sweepId,
-                artifact: {
-                  ...sweep,
-                  surfaceIds: [face_id],
-                },
-              })
-            }
-          }
-        }
-      }
-    )
-    response.data.modeling_response.data.faces.forEach(({ cap, face_id }) => {
-      if ((cap === 'top' || cap === 'bottom') && face_id) {
-        const path = lastPath
-        if (path?.type === 'path') {
-          returnArr.push({
-            id: face_id,
-            artifact: {
-              type: 'cap',
-              id: face_id,
-              subType: cap === 'bottom' ? 'start' : 'end',
-              edgeCutEdgeIds: [],
-              sweepId: path.sweepId,
-              pathIds: [],
-            },
-          })
-          const sweep = getArtifact(path.sweepId)
-          if (sweep?.type !== 'sweep') return
-          returnArr.push({
-            id: path.sweepId,
-            artifact: {
-              ...sweep,
-              surfaceIds: [face_id],
-            },
-          })
-        }
-      }
-    })
-    return returnArr
-  } else if (
-    // is opposite edge
-    (cmd.type === 'solid3d_get_opposite_edge' &&
-      response.type === 'modeling' &&
-      response.data.modeling_response.type === 'solid3d_get_opposite_edge' &&
-      response.data.modeling_response.data.edge) ||
-    // or is adjacent edge
-    (cmd.type === 'solid3d_get_next_adjacent_edge' &&
-      response.type === 'modeling' &&
-      response.data.modeling_response.type ===
-        'solid3d_get_next_adjacent_edge' &&
-      response.data.modeling_response.data.edge)
-  ) {
-    const wall = getArtifact(cmd.face_id)
-    if (wall?.type !== 'wall') return returnArr
-    const sweep = getArtifact(wall.sweepId)
-    if (sweep?.type !== 'sweep') return returnArr
-    const path = getArtifact(sweep.pathId)
-    if (path?.type !== 'path') return returnArr
-    const segment = getArtifact(cmd.edge_id)
-    if (segment?.type !== 'segment') return returnArr
-
-    return [
-      {
-        id: response.data.modeling_response.data.edge,
-        artifact: {
-          type: 'sweepEdge',
-          id: response.data.modeling_response.data.edge,
-          subType:
-            cmd.type === 'solid3d_get_next_adjacent_edge'
-              ? 'adjacent'
-              : 'opposite',
-          segId: cmd.edge_id,
-          sweepId: path.sweepId,
-        },
-      },
-      {
-        id: cmd.edge_id,
-        artifact: {
-          ...segment,
-          edgeIds: [response.data.modeling_response.data.edge],
-        },
-      },
-      {
-        id: path.sweepId,
-        artifact: {
-          ...sweep,
-          edgeIds: [response.data.modeling_response.data.edge],
-        },
-      },
-    ]
-  } else if (cmd.type === 'solid3d_fillet_edge') {
-    returnArr.push({
-      id,
-      artifact: {
-        type: 'edgeCut',
-        id,
-        subType: cmd.cut_type,
-        consumedEdgeId: cmd.edge_id,
-        edgeIds: [],
-        surfaceId: '',
-        codeRef: { range, pathToNode },
-      },
-    })
-    const consumedEdge = getArtifact(cmd.edge_id)
-    if (consumedEdge?.type === 'segment') {
-      returnArr.push({
-        id: cmd.edge_id,
-        artifact: { ...consumedEdge, edgeCutId: id },
-      })
-    }
-    return returnArr
-  }
-  return []
-}
-
 /** filter map items of a specific type */
 export function filterArtifacts<T extends Artifact['type'][]>(
   {
@@ -669,7 +166,7 @@ export function expandPath(
         },
         artifactGraph
       )
-    : undefined
+    : null
   const plane = getArtifactOfTypes(
     { key: path.planeId, types: ['plane', 'wall'] },
     artifactGraph
@@ -722,10 +219,12 @@ export function expandSegment(
     { key: segment.pathId, types: ['path'] },
     artifactGraph
   )
-  const surf = getArtifactOfTypes(
-    { key: segment.surfaceId, types: ['wall'] },
-    artifactGraph
-  )
+  const surf = segment.surfaceId
+    ? getArtifactOfTypes(
+        { key: segment.surfaceId, types: ['wall'] },
+        artifactGraph
+      )
+    : undefined
   const edges = getArtifactsOfTypes(
     { keys: segment.edgeIds, types: ['sweepEdge'] },
     artifactGraph
@@ -769,11 +268,11 @@ export function getCapCodeRef(
 }
 
 export function getSolid2dCodeRef(
-  solid2D: solid2D,
+  solid2d: Solid2D,
   artifactGraph: ArtifactGraph
 ): CodeRef | Error {
   const path = getArtifactOfTypes(
-    { key: solid2D.pathId, types: ['path'] },
+    { key: solid2d.pathId, types: ['path'] },
     artifactGraph
   )
   if (err(path)) return path
@@ -842,6 +341,7 @@ export function getSweepFromSuspectedSweepSurface(
       artifactGraph
     )
     if (err(path)) return path
+    if (!path.sweepId) return new Error('Path does not have a sweepId')
     return getArtifactOfTypes(
       { key: path.sweepId, types: ['sweep'] },
       artifactGraph
@@ -859,6 +359,7 @@ export function getSweepFromSuspectedPath(
 ): SweepArtifact | Error {
   const path = getArtifactOfTypes({ key: id, types: ['path'] }, artifactGraph)
   if (err(path)) return path
+  if (!path.sweepId) return new Error('Path does not have a sweepId')
   return getArtifactOfTypes(
     { key: path.sweepId, types: ['sweep'] },
     artifactGraph
@@ -870,7 +371,7 @@ export function getCodeRefsByArtifactId(
   artifactGraph: ArtifactGraph
 ): Array<CodeRef> | null {
   const artifact = artifactGraph.get(id)
-  if (artifact?.type === 'solid2D') {
+  if (artifact?.type === 'solid2d') {
     const codeRef = getSolid2dCodeRef(artifact, artifactGraph)
     if (err(codeRef)) return null
     return [codeRef]

src/lang/std/engineConnection.ts

@@ -1,9 +1,7 @@
 import {
-  ArtifactCommand,
-  defaultRustSourceRange,
+  ArtifactGraph,
+  defaultSourceRange,
   ExecState,
-  Program,
-  RustSourceRange,
   SourceRange,
 } from 'lang/wasm'
 import { VITE_KC_API_WS_MODELING_URL, VITE_KC_DEV_TOKEN } from 'env'
@@ -17,12 +15,7 @@ import {
   darkModeMatcher,
 } from 'lib/theme'
 import { DefaultPlanes } from 'wasm-lib/kcl/bindings/DefaultPlanes'
-import {
-  ArtifactGraph,
-  EngineCommand,
-  ResponseMap,
-  createArtifactGraph,
-} from 'lang/std/artifactGraph'
+import { EngineCommand, ResponseMap } from 'lang/std/artifactGraph'
 import { useModelingContext } from 'hooks/useModelingContext'
 import { exportMake } from 'lib/exportMake'
 import toast from 'react-hot-toast'
@@ -36,7 +29,6 @@ import { KclManager } from 'lang/KclSingleton'
 import { reportRejection } from 'lib/trap'
 import { markOnce } from 'lib/performance'
 import { MachineManager } from 'components/MachineManagerProvider'
-import { Node } from 'wasm-lib/kcl/bindings/Node'
 
 // TODO(paultag): This ought to be tweakable.
 const pingIntervalMs = 5_000
@@ -1309,8 +1301,8 @@ export enum EngineCommandManagerEvents {
 
 interface PendingMessage {
   command: EngineCommand
-  range: RustSourceRange
-  idToRangeMap: { [key: string]: RustSourceRange }
+  range: SourceRange
+  idToRangeMap: { [key: string]: SourceRange }
   resolve: (data: [Models['WebSocketResponse_type']]) => void
   reject: (reason: string) => void
   promise: Promise<[Models['WebSocketResponse_type']]>
@@ -1994,7 +1986,7 @@ export class EngineCommandManager extends EventTarget {
       {
         command,
         idToRangeMap: {},
-        range: defaultRustSourceRange(),
+        range: defaultSourceRange(),
       },
       true // isSceneCommand
     )
@@ -2025,9 +2017,9 @@ export class EngineCommandManager extends EventTarget {
       return Promise.reject(new Error('rangeStr is undefined'))
     if (commandStr === undefined)
       return Promise.reject(new Error('commandStr is undefined'))
-    const range: RustSourceRange = JSON.parse(rangeStr)
+    const range: SourceRange = JSON.parse(rangeStr)
     const command: EngineCommand = JSON.parse(commandStr)
-    const idToRangeMap: { [key: string]: RustSourceRange } =
+    const idToRangeMap: { [key: string]: SourceRange } =
       JSON.parse(idToRangeStr)
 
     // Current executeAst is stale, going to interrupt, a new executeAst will trigger
@@ -2087,17 +2079,8 @@ export class EngineCommandManager extends EventTarget {
       Object.values(this.pendingCommands).map((a) => a.promise)
     )
   }
-  updateArtifactGraph(
-    ast: Node<Program>,
-    artifactCommands: ArtifactCommand[],
-    execStateArtifacts: ExecState['artifacts']
-  ) {
-    this.artifactGraph = createArtifactGraph({
-      artifactCommands,
-      responseMap: this.responseMap,
-      ast,
-      execStateArtifacts,
-    })
+  updateArtifactGraph(execStateArtifactGraph: ExecState['artifactGraph']) {
+    this.artifactGraph = execStateArtifactGraph
     // TODO check if these still need to be deferred once e2e tests are working again.
     if (this.artifactGraph.size) {
       this.deferredArtifactEmptied(null)

src/lang/std/fileSystemManager.ts

@@ -1,5 +1,21 @@
 import { isDesktop } from 'lib/isDesktop'
 
+// Polyfill window.electron fs functions as needed when in a nodejs context
+// (INTENDED FOR VITEST SHINANGANS.)
+if (process.env.NODE_ENV === 'test' && process.env.VITEST) {
+  const fs = require('node:fs/promises')
+  const path = require('node:path')
+  Object.assign(window, {
+    electron: {
+      readFile: fs.readFile,
+      stat: fs.stat,
+      readdir: fs.readdir,
+      path,
+      process: {},
+    },
+  })
+}
+
 /// FileSystemManager is a class that provides a way to read files from the local file system.
 /// It assumes that you are in a project since it is solely used by the std lib
 /// when executing code.
@@ -19,13 +35,9 @@ class FileSystemManager {
   }
 
   async readFile(path: string): Promise<Uint8Array> {
-    // Using local file system only works from desktop.
-    if (!isDesktop()) {
-      return Promise.reject(
-        new Error(
-          'This function can only be called from the desktop application'
-        )
-      )
+    // Using local file system only works from desktop and nodejs
+    if (!window?.electron?.readFile) {
+      return Promise.reject(new Error('No polyfill found for this function'))
     }
 
     return this.join(this.dir, path).then((filePath) => {
@@ -35,12 +47,8 @@ class FileSystemManager {
 
   async exists(path: string): Promise<boolean | void> {
     // Using local file system only works from desktop.
-    if (!isDesktop()) {
-      return Promise.reject(
-        new Error(
-          'This function can only be called from the desktop application'
-        )
-      )
+    if (!window?.electron?.stat) {
+      return Promise.reject(new Error('No polyfill found for this function'))
     }
 
     return this.join(this.dir, path).then(async (file) => {
@@ -57,12 +65,8 @@ class FileSystemManager {
 
   async getAllFiles(path: string): Promise<string[] | void> {
     // Using local file system only works from desktop.
-    if (!isDesktop()) {
-      return Promise.reject(
-        new Error(
-          'This function can only be called from the desktop application'
-        )
-      )
+    if (!window?.electron?.readdir) {
+      return Promise.reject(new Error('No polyfill found for this function'))
     }
 
     return this.join(this.dir, path).then((filepath) => {

src/lang/std/sketch.test.ts

@@ -11,8 +11,8 @@ import {
   assertParse,
   recast,
   initPromise,
-  SourceRange,
   CallExpression,
+  topLevelRange,
 } from '../wasm'
 import { getNodeFromPath, getNodePathFromSourceRange } from '../queryAst'
 import { enginelessExecutor } from '../../lib/testHelpers'
@@ -124,7 +124,10 @@ describe('testing changeSketchArguments', () => {
       execState.memory,
       {
         type: 'sourceRange',
-        sourceRange: [sourceStart, sourceStart + lineToChange.length, true],
+        sourceRange: topLevelRange(
+          sourceStart,
+          sourceStart + lineToChange.length
+        ),
       },
       {
         type: 'straight-segment',
@@ -219,11 +222,10 @@ describe('testing addTagForSketchOnFace', () => {
     const ast = assertParse(code)
     await enginelessExecutor(ast)
     const sourceStart = code.indexOf(originalLine)
-    const sourceRange: [number, number, boolean] = [
+    const sourceRange = topLevelRange(
       sourceStart,
-      sourceStart + originalLine.length,
-      true,
-    ]
+      sourceStart + originalLine.length
+    )
     if (err(ast)) return ast
     const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
     const sketchOnFaceRetVal = addTagForSketchOnFace(
@@ -292,11 +294,10 @@ ${insertCode}
       await enginelessExecutor(ast)
       const sourceStart = code.indexOf(originalChamfer)
       const extraChars = originalChamfer.indexOf('chamfer')
-      const sourceRange: [number, number, boolean] = [
+      const sourceRange = topLevelRange(
         sourceStart + extraChars,
-        sourceStart + originalChamfer.length - extraChars,
-        true,
-      ]
+        sourceStart + originalChamfer.length - extraChars
+      )
 
       if (err(ast)) throw ast
       const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
@@ -357,7 +358,6 @@ describe('testing getConstraintInfo', () => {
     offset = 0
   }, %)
   |> tangentialArcTo([3.14, 13.14], %)`
-    const ast = assertParse(code)
     test.each([
       [
         'line',
@@ -366,7 +366,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: false,
             value: '3',
-            sourceRange: [78, 79, true],
+            sourceRange: topLevelRange(78, 79),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'line',
@@ -375,7 +375,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: false,
             value: '4',
-            sourceRange: [81, 82, true],
+            sourceRange: topLevelRange(81, 82),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'line',
@@ -389,7 +389,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [118, 122, true],
+            sourceRange: topLevelRange(118, 122),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -398,7 +398,7 @@ describe('testing getConstraintInfo', () => {
             type: 'length',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [137, 141, true],
+            sourceRange: topLevelRange(137, 141),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -412,7 +412,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: false,
             value: '6.14',
-            sourceRange: [164, 168, true],
+            sourceRange: topLevelRange(164, 168),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'lineTo',
@@ -421,7 +421,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [170, 174, true],
+            sourceRange: topLevelRange(170, 174),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'lineTo',
@@ -435,7 +435,7 @@ describe('testing getConstraintInfo', () => {
             type: 'horizontal',
             isConstrained: true,
             value: 'xLineTo',
-            sourceRange: [185, 192, true],
+            sourceRange: topLevelRange(185, 192),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLineTo',
@@ -444,7 +444,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: false,
             value: '8',
-            sourceRange: [193, 194, true],
+            sourceRange: topLevelRange(193, 194),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLineTo',
@@ -458,7 +458,7 @@ describe('testing getConstraintInfo', () => {
             type: 'vertical',
             isConstrained: true,
             value: 'yLineTo',
-            sourceRange: [204, 211, true],
+            sourceRange: topLevelRange(204, 211),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLineTo',
@@ -467,7 +467,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: false,
             value: '5',
-            sourceRange: [212, 213, true],
+            sourceRange: topLevelRange(212, 213),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLineTo',
@@ -481,7 +481,7 @@ describe('testing getConstraintInfo', () => {
             type: 'vertical',
             isConstrained: true,
             value: 'yLine',
-            sourceRange: [223, 228, true],
+            sourceRange: topLevelRange(223, 228),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLine',
@@ -490,7 +490,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [229, 233, true],
+            sourceRange: topLevelRange(229, 233),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLine',
@@ -504,7 +504,7 @@ describe('testing getConstraintInfo', () => {
             type: 'horizontal',
             isConstrained: true,
             value: 'xLine',
-            sourceRange: [247, 252, true],
+            sourceRange: topLevelRange(247, 252),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLine',
@@ -513,7 +513,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [253, 257, true],
+            sourceRange: topLevelRange(253, 257),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLine',
@@ -527,7 +527,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [301, 305, true],
+            sourceRange: topLevelRange(301, 305),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -536,7 +536,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [320, 324, true],
+            sourceRange: topLevelRange(320, 324),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -550,7 +550,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '30',
-            sourceRange: [373, 375, true],
+            sourceRange: topLevelRange(373, 375),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -559,7 +559,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: false,
             value: '3',
-            sourceRange: [390, 391, true],
+            sourceRange: topLevelRange(390, 391),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -573,7 +573,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '12.14',
-            sourceRange: [434, 439, true],
+            sourceRange: topLevelRange(434, 439),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -582,7 +582,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: false,
             value: '12',
-            sourceRange: [450, 452, true],
+            sourceRange: topLevelRange(450, 452),
             argPosition: { type: 'objectProperty', key: 'to' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -596,7 +596,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '30',
-            sourceRange: [495, 497, true],
+            sourceRange: topLevelRange(495, 497),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -605,7 +605,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: false,
             value: '10.14',
-            sourceRange: [508, 513, true],
+            sourceRange: topLevelRange(508, 513),
             argPosition: { type: 'objectProperty', key: 'to' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -619,7 +619,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [567, 571, true],
+            sourceRange: topLevelRange(567, 571),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineThatIntersects',
@@ -628,7 +628,7 @@ describe('testing getConstraintInfo', () => {
             type: 'intersectionOffset',
             isConstrained: false,
             value: '0',
-            sourceRange: [608, 609, true],
+            sourceRange: topLevelRange(608, 609),
             argPosition: { type: 'objectProperty', key: 'offset' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineThatIntersects',
@@ -637,7 +637,7 @@ describe('testing getConstraintInfo', () => {
             type: 'intersectionTag',
             isConstrained: false,
             value: 'a',
-            sourceRange: [592, 593, true],
+            sourceRange: topLevelRange(592, 593),
             argPosition: {
               key: 'intersectTag',
               type: 'objectProperty',
@@ -654,7 +654,7 @@ describe('testing getConstraintInfo', () => {
             type: 'tangentialWithPrevious',
             isConstrained: true,
             value: 'tangentialArcTo',
-            sourceRange: [623, 638, true],
+            sourceRange: topLevelRange(623, 638),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -663,7 +663,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [640, 644, true],
+            sourceRange: topLevelRange(640, 644),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -672,7 +672,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: false,
             value: '13.14',
-            sourceRange: [646, 651, true],
+            sourceRange: topLevelRange(646, 651),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -680,11 +680,11 @@ describe('testing getConstraintInfo', () => {
         ],
       ],
     ])('testing %s when inputs are unconstrained', (functionName, expected) => {
-      const sourceRange: SourceRange = [
+      const ast = assertParse(code)
+      const sourceRange = topLevelRange(
         code.indexOf(functionName),
-        code.indexOf(functionName) + functionName.length,
-        true,
-      ]
+        code.indexOf(functionName) + functionName.length
+      )
       if (err(ast)) return ast
       const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
       const callExp = getNodeFromPath<Node<CallExpression>>(
@@ -717,7 +717,6 @@ describe('testing getConstraintInfo', () => {
          offset = 0
        }, %)
     |> tangentialArcTo([3.14, 13.14], %)`
-    const ast = assertParse(code)
     test.each([
       [
         `angledLine(`,
@@ -726,7 +725,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [112, 116, true],
+            sourceRange: topLevelRange(112, 116),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -735,7 +734,7 @@ describe('testing getConstraintInfo', () => {
             type: 'length',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [118, 122, true],
+            sourceRange: topLevelRange(118, 122),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -749,7 +748,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [277, 281, true],
+            sourceRange: topLevelRange(277, 281),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -758,7 +757,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: false,
             value: '3.14',
-            sourceRange: [283, 287, true],
+            sourceRange: topLevelRange(283, 287),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -772,7 +771,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '30',
-            sourceRange: [321, 323, true],
+            sourceRange: topLevelRange(321, 323),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -781,7 +780,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: false,
             value: '3',
-            sourceRange: [325, 326, true],
+            sourceRange: topLevelRange(325, 326),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -795,7 +794,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '12',
-            sourceRange: [354, 356, true],
+            sourceRange: topLevelRange(354, 356),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -804,7 +803,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: false,
             value: '12',
-            sourceRange: [358, 360, true],
+            sourceRange: topLevelRange(358, 360),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -818,7 +817,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: false,
             value: '30',
-            sourceRange: [388, 390, true],
+            sourceRange: topLevelRange(388, 390),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -827,7 +826,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: false,
             value: '10',
-            sourceRange: [392, 394, true],
+            sourceRange: topLevelRange(392, 394),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -835,11 +834,11 @@ describe('testing getConstraintInfo', () => {
         ],
       ],
     ])('testing %s when inputs are unconstrained', (functionName, expected) => {
-      const sourceRange: SourceRange = [
+      const ast = assertParse(code)
+      const sourceRange = topLevelRange(
         code.indexOf(functionName),
-        code.indexOf(functionName) + functionName.length,
-        true,
-      ]
+        code.indexOf(functionName) + functionName.length
+      )
       if (err(ast)) return ast
       const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
       const callExp = getNodeFromPath<Node<CallExpression>>(
@@ -872,7 +871,6 @@ describe('testing getConstraintInfo', () => {
          offset = 0 + 0
        }, %)
     |> tangentialArcTo([3.14 + 0, 13.14 + 0], %)`
-    const ast = assertParse(code)
     test.each([
       [
         'line',
@@ -881,7 +879,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: true,
             value: '3 + 0',
-            sourceRange: [83, 88, true],
+            sourceRange: topLevelRange(83, 88),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'line',
@@ -890,7 +888,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: true,
             value: '4 + 0',
-            sourceRange: [90, 95, true],
+            sourceRange: topLevelRange(90, 95),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'line',
@@ -904,7 +902,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [129, 137, true],
+            sourceRange: topLevelRange(129, 137),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -913,7 +911,7 @@ describe('testing getConstraintInfo', () => {
             type: 'length',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [148, 156, true],
+            sourceRange: topLevelRange(148, 156),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLine',
@@ -927,7 +925,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: true,
             value: '6.14 + 0',
-            sourceRange: [178, 186, true],
+            sourceRange: topLevelRange(178, 186),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'lineTo',
@@ -936,7 +934,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [188, 196, true],
+            sourceRange: topLevelRange(188, 196),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'lineTo',
@@ -950,7 +948,7 @@ describe('testing getConstraintInfo', () => {
             type: 'horizontal',
             isConstrained: true,
             value: 'xLineTo',
-            sourceRange: [209, 216, true],
+            sourceRange: topLevelRange(209, 216),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLineTo',
@@ -959,7 +957,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: true,
             value: '8 + 0',
-            sourceRange: [217, 222, true],
+            sourceRange: topLevelRange(217, 222),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLineTo',
@@ -973,7 +971,7 @@ describe('testing getConstraintInfo', () => {
             type: 'vertical',
             isConstrained: true,
             value: 'yLineTo',
-            sourceRange: [234, 241, true],
+            sourceRange: topLevelRange(234, 241),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLineTo',
@@ -982,7 +980,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: true,
             value: '5 + 0',
-            sourceRange: [242, 247, true],
+            sourceRange: topLevelRange(242, 247),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLineTo',
@@ -996,7 +994,7 @@ describe('testing getConstraintInfo', () => {
             type: 'vertical',
             isConstrained: true,
             value: 'yLine',
-            sourceRange: [259, 264, true],
+            sourceRange: topLevelRange(259, 264),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLine',
@@ -1005,7 +1003,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [265, 273, true],
+            sourceRange: topLevelRange(265, 273),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'yLine',
@@ -1019,7 +1017,7 @@ describe('testing getConstraintInfo', () => {
             type: 'horizontal',
             isConstrained: true,
             value: 'xLine',
-            sourceRange: [289, 294, true],
+            sourceRange: topLevelRange(289, 294),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLine',
@@ -1028,7 +1026,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [295, 303, true],
+            sourceRange: topLevelRange(295, 303),
             argPosition: { type: 'singleValue' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'xLine',
@@ -1042,7 +1040,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [345, 353, true],
+            sourceRange: topLevelRange(345, 353),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -1051,7 +1049,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xRelative',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [364, 372, true],
+            sourceRange: topLevelRange(364, 372),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfXLength',
@@ -1065,7 +1063,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '30 + 0',
-            sourceRange: [416, 422, true],
+            sourceRange: topLevelRange(416, 422),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -1074,7 +1072,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yRelative',
             isConstrained: true,
             value: '3 + 0',
-            sourceRange: [433, 438, true],
+            sourceRange: topLevelRange(433, 438),
             argPosition: { type: 'objectProperty', key: 'length' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineOfYLength',
@@ -1088,7 +1086,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '12.14 + 0',
-            sourceRange: [476, 485, true],
+            sourceRange: topLevelRange(476, 485),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -1097,7 +1095,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: true,
             value: '12 + 0',
-            sourceRange: [492, 498, true],
+            sourceRange: topLevelRange(492, 498),
             argPosition: { type: 'objectProperty', key: 'to' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToX',
@@ -1111,7 +1109,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '30 + 0',
-            sourceRange: [536, 542, true],
+            sourceRange: topLevelRange(536, 542),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -1120,7 +1118,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: true,
             value: '10.14 + 0',
-            sourceRange: [549, 558, true],
+            sourceRange: topLevelRange(549, 558),
             argPosition: { type: 'objectProperty', key: 'to' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineToY',
@@ -1134,7 +1132,7 @@ describe('testing getConstraintInfo', () => {
             type: 'angle',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [616, 624, true],
+            sourceRange: topLevelRange(616, 624),
             argPosition: { type: 'objectProperty', key: 'angle' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineThatIntersects',
@@ -1143,7 +1141,7 @@ describe('testing getConstraintInfo', () => {
             type: 'intersectionOffset',
             isConstrained: true,
             value: '0 + 0',
-            sourceRange: [671, 676, true],
+            sourceRange: topLevelRange(671, 676),
             argPosition: { type: 'objectProperty', key: 'offset' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineThatIntersects',
@@ -1152,7 +1150,7 @@ describe('testing getConstraintInfo', () => {
             type: 'intersectionTag',
             isConstrained: false,
             value: 'a',
-            sourceRange: [650, 651, true],
+            sourceRange: topLevelRange(650, 651),
             argPosition: { key: 'intersectTag', type: 'objectProperty' },
             pathToNode: expect.any(Array),
             stdLibFnName: 'angledLineThatIntersects',
@@ -1166,7 +1164,7 @@ describe('testing getConstraintInfo', () => {
             type: 'tangentialWithPrevious',
             isConstrained: true,
             value: 'tangentialArcTo',
-            sourceRange: [697, 712, true],
+            sourceRange: topLevelRange(697, 712),
             argPosition: undefined,
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -1175,7 +1173,7 @@ describe('testing getConstraintInfo', () => {
             type: 'xAbsolute',
             isConstrained: true,
             value: '3.14 + 0',
-            sourceRange: [714, 722, true],
+            sourceRange: topLevelRange(714, 722),
             argPosition: { type: 'arrayItem', index: 0 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -1184,7 +1182,7 @@ describe('testing getConstraintInfo', () => {
             type: 'yAbsolute',
             isConstrained: true,
             value: '13.14 + 0',
-            sourceRange: [724, 733, true],
+            sourceRange: topLevelRange(724, 733),
             argPosition: { type: 'arrayItem', index: 1 },
             pathToNode: expect.any(Array),
             stdLibFnName: 'tangentialArcTo',
@@ -1192,11 +1190,11 @@ describe('testing getConstraintInfo', () => {
         ],
       ],
     ])('testing %s when inputs are unconstrained', (functionName, expected) => {
-      const sourceRange: SourceRange = [
+      const ast = assertParse(code)
+      const sourceRange = topLevelRange(
         code.indexOf(functionName),
-        code.indexOf(functionName) + functionName.length,
-        true,
-      ]
+        code.indexOf(functionName) + functionName.length
+      )
       if (err(ast)) return ast
       const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
       const callExp = getNodeFromPath<Node<CallExpression>>(

src/lang/std/sketch.ts

@@ -12,6 +12,7 @@ import {
   VariableDeclaration,
   Identifier,
   sketchFromKclValue,
+  topLevelRange,
 } from 'lang/wasm'
 import {
   getNodeFromPath,
@@ -222,7 +223,7 @@ const commonConstraintInfoHelper = (
         code.slice(input1.start, input1.end),
         stdLibFnName,
         isArr ? abbreviatedInputs[0].arrayInput : abbreviatedInputs[0].objInput,
-        [input1.start, input1.end, true],
+        topLevelRange(input1.start, input1.end),
         pathToFirstArg
       )
     )
@@ -234,7 +235,7 @@ const commonConstraintInfoHelper = (
         code.slice(input2.start, input2.end),
         stdLibFnName,
         isArr ? abbreviatedInputs[1].arrayInput : abbreviatedInputs[1].objInput,
-        [input2.start, input2.end, true],
+        topLevelRange(input2.start, input2.end),
         pathToSecondArg
       )
     )
@@ -266,7 +267,7 @@ const horzVertConstraintInfoHelper = (
       callee.name,
       stdLibFnName,
       undefined,
-      [callee.start, callee.end, true],
+      topLevelRange(callee.start, callee.end),
       pathToCallee
     ),
     constrainInfo(
@@ -275,7 +276,7 @@ const horzVertConstraintInfoHelper = (
       code.slice(firstArg.start, firstArg.end),
       stdLibFnName,
       abbreviatedInput,
-      [firstArg.start, firstArg.end, true],
+      topLevelRange(firstArg.start, firstArg.end),
       pathToFirstArg
     ),
   ]
@@ -905,7 +906,7 @@ export const tangentialArcTo: SketchLineHelper = {
         callee.name,
         'tangentialArcTo',
         undefined,
-        [callee.start, callee.end, true],
+        topLevelRange(callee.start, callee.end),
         pathToCallee
       ),
       constrainInfo(
@@ -914,7 +915,7 @@ export const tangentialArcTo: SketchLineHelper = {
         code.slice(firstArg.elements[0].start, firstArg.elements[0].end),
         'tangentialArcTo',
         0,
-        [firstArg.elements[0].start, firstArg.elements[0].end, true],
+        topLevelRange(firstArg.elements[0].start, firstArg.elements[0].end),
         pathToFirstArg
       ),
       constrainInfo(
@@ -923,7 +924,7 @@ export const tangentialArcTo: SketchLineHelper = {
         code.slice(firstArg.elements[1].start, firstArg.elements[1].end),
         'tangentialArcTo',
         1,
-        [firstArg.elements[1].start, firstArg.elements[1].end, true],
+        topLevelRange(firstArg.elements[1].start, firstArg.elements[1].end),
         pathToSecondArg
       ),
     ]
@@ -1052,7 +1053,7 @@ export const circle: SketchLineHelper = {
         code.slice(radiusDetails.expr.start, radiusDetails.expr.end),
         'circle',
         'radius',
-        [radiusDetails.expr.start, radiusDetails.expr.end, true],
+        topLevelRange(radiusDetails.expr.start, radiusDetails.expr.end),
         pathToRadiusLiteral
       ),
       {
@@ -1061,11 +1062,10 @@ export const circle: SketchLineHelper = {
         isConstrained: isNotLiteralArrayOrStatic(
           centerDetails.expr.elements[0]
         ),
-        sourceRange: [
+        sourceRange: topLevelRange(
           centerDetails.expr.elements[0].start,
-          centerDetails.expr.elements[0].end,
-          true,
-        ],
+          centerDetails.expr.elements[0].end
+        ),
         pathToNode: pathToXArg,
         value: code.slice(
           centerDetails.expr.elements[0].start,
@@ -1083,11 +1083,10 @@ export const circle: SketchLineHelper = {
         isConstrained: isNotLiteralArrayOrStatic(
           centerDetails.expr.elements[1]
         ),
-        sourceRange: [
+        sourceRange: topLevelRange(
           centerDetails.expr.elements[1].start,
-          centerDetails.expr.elements[1].end,
-          true,
-        ],
+          centerDetails.expr.elements[1].end
+        ),
         pathToNode: pathToYArg,
         value: code.slice(
           centerDetails.expr.elements[1].start,
@@ -1763,7 +1762,7 @@ export const angledLineThatIntersects: SketchLineHelper = {
           code.slice(angle.start, angle.end),
           'angledLineThatIntersects',
           'angle',
-          [angle.start, angle.end, true],
+          topLevelRange(angle.start, angle.end),
           pathToAngleProp
         )
       )
@@ -1782,7 +1781,7 @@ export const angledLineThatIntersects: SketchLineHelper = {
           code.slice(offset.start, offset.end),
           'angledLineThatIntersects',
           'offset',
-          [offset.start, offset.end, true],
+          topLevelRange(offset.start, offset.end),
           pathToOffsetProp
         )
       )
@@ -1801,7 +1800,7 @@ export const angledLineThatIntersects: SketchLineHelper = {
         code.slice(tag.start, tag.end),
         'angledLineThatIntersects',
         'intersectTag',
-        [tag.start, tag.end, true],
+        topLevelRange(tag.start, tag.end),
         pathToTagProp
       )
       returnVal.push(info)

src/lang/std/sketchConstraints.test.ts

@@ -5,6 +5,7 @@ import {
   initPromise,
   sketchFromKclValue,
   SourceRange,
+  topLevelRange,
 } from '../wasm'
 import {
   ConstraintType,
@@ -31,10 +32,10 @@ async function testingSwapSketchFnCall({
   constraintType: ConstraintType
 }): Promise<{
   newCode: string
-  originalRange: [number, number, boolean]
+  originalRange: SourceRange
 }> {
   const startIndex = inputCode.indexOf(callToSwap)
-  const range: SourceRange = [startIndex, startIndex + callToSwap.length, true]
+  const range = topLevelRange(startIndex, startIndex + callToSwap.length)
   const ast = assertParse(inputCode)
 
   const execState = await enginelessExecutor(ast)
@@ -375,7 +376,10 @@ part001 = startSketchOn('XY')
       execState.memory.get('part001'),
       'part001'
     ) as Sketch
-    const _segment = getSketchSegmentFromSourceRange(sg, [index, index, true])
+    const _segment = getSketchSegmentFromSourceRange(
+      sg,
+      topLevelRange(index, index)
+    )
     if (err(_segment)) throw _segment
     const { __geoMeta, ...segment } = _segment.segment
     expect(segment).toEqual({
@@ -390,7 +394,7 @@ part001 = startSketchOn('XY')
     const index = code.indexOf('// segment-in-start') - 7
     const _segment = getSketchSegmentFromSourceRange(
       sketchFromKclValue(execState.memory.get('part001'), 'part001') as Sketch,
-      [index, index, true]
+      topLevelRange(index, index)
     )
     if (err(_segment)) throw _segment
     const { __geoMeta, ...segment } = _segment.segment

src/lang/std/sketchConstraints.ts

@@ -9,6 +9,7 @@ import {
   Path,
   PathToNode,
   Expr,
+  topLevelRange,
 } from '../wasm'
 import { err } from 'lib/trap'
 
@@ -31,7 +32,7 @@ export function getSketchSegmentFromPathToNode(
   const node = nodeMeta.node
   if (!node || typeof node.start !== 'number' || !node.end)
     return new Error('no node found')
-  const sourceRange: SourceRange = [node.start, node.end, true]
+  const sourceRange = topLevelRange(node.start, node.end)
   return getSketchSegmentFromSourceRange(sketch, sourceRange)
 }
 export function getSketchSegmentFromSourceRange(

src/lang/std/sketchcombos.test.ts

@@ -1,4 +1,11 @@
-import { assertParse, Expr, recast, initPromise, Program } from '../wasm'
+import {
+  assertParse,
+  Expr,
+  recast,
+  initPromise,
+  Program,
+  topLevelRange,
+} from '../wasm'
 import {
   getConstraintType,
   getTransformInfos,
@@ -125,7 +132,7 @@ describe('testing transformAstForSketchLines for equal length constraint', () =>
         )
       }
       const start = codeBeforeLine + line.indexOf('|> ' + 5)
-      const range: [number, number, boolean] = [start, start, true]
+      const range = topLevelRange(start, start)
       return {
         codeRef: codeRefFromRange(range, ast),
       }
@@ -297,7 +304,7 @@ part001 = startSketchOn('XY')
         const comment = ln.split('//')[1]
         const start = inputScript.indexOf('//' + comment) - 7
         return {
-          codeRef: codeRefFromRange([start, start, true], ast),
+          codeRef: codeRefFromRange(topLevelRange(start, start), ast),
         }
       })
 
@@ -386,7 +393,7 @@ part001 = startSketchOn('XY')
         const comment = ln.split('//')[1]
         const start = inputScript.indexOf('//' + comment) - 7
         return {
-          codeRef: codeRefFromRange([start, start, true], ast),
+          codeRef: codeRefFromRange(topLevelRange(start, start), ast),
         }
       })
 
@@ -446,7 +453,7 @@ part001 = startSketchOn('XY')
         const comment = ln.split('//')[1]
         const start = inputScript.indexOf('//' + comment) - 7
         return {
-          codeRef: codeRefFromRange([start, start, true], ast),
+          codeRef: codeRefFromRange(topLevelRange(start, start), ast),
         }
       })
 
@@ -541,7 +548,7 @@ async function helperThing(
       const comment = ln.split('//')[1]
       const start = inputScript.indexOf('//' + comment) - 7
       return {
-        codeRef: codeRefFromRange([start, start, true], ast),
+        codeRef: codeRefFromRange(topLevelRange(start, start), ast),
       }
     })
 
@@ -610,7 +617,7 @@ part001 = startSketchOn('XY')
         }
         const offsetIndex = index - 7
         const expectedConstraintLevel = getConstraintLevelFromSourceRange(
-          [offsetIndex, offsetIndex, true],
+          topLevelRange(offsetIndex, offsetIndex),
           ast
         )
         if (err(expectedConstraintLevel)) {

src/lang/util.ts

@@ -5,8 +5,9 @@ import {
   Literal,
   ArrayExpression,
   BinaryExpression,
+  ArtifactGraph,
 } from './wasm'
-import { ArtifactGraph, filterArtifacts } from 'lang/std/artifactGraph'
+import { filterArtifacts } from 'lang/std/artifactGraph'
 import { isOverlap } from 'lib/utils'
 
 export function updatePathToNodeFromMap(

src/lang/wasm.ts

@@ -44,17 +44,30 @@ import { EnvironmentRef } from '../wasm-lib/kcl/bindings/EnvironmentRef'
 import { Environment } from '../wasm-lib/kcl/bindings/Environment'
 import { Node } from 'wasm-lib/kcl/bindings/Node'
 import { CompilationError } from 'wasm-lib/kcl/bindings/CompilationError'
-import { SourceRange as RustSourceRange } from 'wasm-lib/kcl/bindings/SourceRange'
+import { SourceRange } from 'wasm-lib/kcl/bindings/SourceRange'
 import { getAllCurrentSettings } from 'lib/settings/settingsUtils'
 import { Operation } from 'wasm-lib/kcl/bindings/Operation'
 import { KclErrorWithOutputs } from 'wasm-lib/kcl/bindings/KclErrorWithOutputs'
-import { Artifact } from 'wasm-lib/kcl/bindings/Artifact'
-import { ArtifactId } from 'wasm-lib/kcl/bindings/ArtifactId'
-import { ArtifactCommand } from 'wasm-lib/kcl/bindings/ArtifactCommand'
+import { Artifact as RustArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+import { ArtifactId } from 'wasm-lib/kcl/bindings/Artifact'
+import { ArtifactCommand } from 'wasm-lib/kcl/bindings/Artifact'
+import { ArtifactGraph as RustArtifactGraph } from 'wasm-lib/kcl/bindings/Artifact'
+import { Artifact } from './std/artifactGraph'
+import { getNodePathFromSourceRange } from './queryAst'
 
 export type { Artifact } from 'wasm-lib/kcl/bindings/Artifact'
-export type { ArtifactCommand } from 'wasm-lib/kcl/bindings/ArtifactCommand'
-export type { ArtifactId } from 'wasm-lib/kcl/bindings/ArtifactId'
+export type { ArtifactCommand } from 'wasm-lib/kcl/bindings/Artifact'
+export type { ArtifactId } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Cap as CapArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { CodeRef } from 'wasm-lib/kcl/bindings/Artifact'
+export type { EdgeCut } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Path as PathArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Plane as PlaneArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Segment as SegmentArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Solid2d as Solid2dArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Sweep as SweepArtifact } from 'wasm-lib/kcl/bindings/Artifact'
+export type { SweepEdge } from 'wasm-lib/kcl/bindings/Artifact'
+export type { Wall as WallArtifact } from 'wasm-lib/kcl/bindings/Artifact'
 export type { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
 export type { Program } from '../wasm-lib/kcl/bindings/Program'
 export type { Expr } from '../wasm-lib/kcl/bindings/Expr'
@@ -76,7 +89,7 @@ export type { BinaryPart } from '../wasm-lib/kcl/bindings/BinaryPart'
 export type { Literal } from '../wasm-lib/kcl/bindings/Literal'
 export type { LiteralValue } from '../wasm-lib/kcl/bindings/LiteralValue'
 export type { ArrayExpression } from '../wasm-lib/kcl/bindings/ArrayExpression'
-export type { SourceRange as RustSourceRange } from 'wasm-lib/kcl/bindings/SourceRange'
+export type { SourceRange } from 'wasm-lib/kcl/bindings/SourceRange'
 
 export type SyntaxType =
   | 'Program'
@@ -105,35 +118,36 @@ export type { Solid } from '../wasm-lib/kcl/bindings/Solid'
 export type { KclValue } from '../wasm-lib/kcl/bindings/KclValue'
 export type { ExtrudeSurface } from '../wasm-lib/kcl/bindings/ExtrudeSurface'
 
-/**
- * The first two items are the start and end points (byte offsets from the start of the file).
- * The third item is whether the source range belongs to the 'main' file, i.e., the file currently
- * being rendered/displayed in the editor (TODO we need to handle modules better in the frontend).
- */
-export type SourceRange = [number, number, boolean]
-
 /**
  * Convert a SourceRange as used inside the KCL interpreter into the above one for use in the
  * frontend (essentially we're eagerly checking whether the frontend should care about the SourceRange
  * so as not to expose details of the interpreter's current representation of module ids throughout
  * the frontend).
  */
-export function sourceRangeFromRust(s: RustSourceRange): SourceRange {
-  return [s[0], s[1], s[2] === 0]
+export function sourceRangeFromRust(s: SourceRange): SourceRange {
+  return [s[0], s[1], s[2]]
 }
 
 /**
  * Create a default SourceRange for testing or as a placeholder.
  */
 export function defaultSourceRange(): SourceRange {
-  return [0, 0, true]
+  return [0, 0, 0]
 }
 
 /**
- * Create a default RustSourceRange for testing or as a placeholder.
+ * Create a SourceRange for the top-level module.
  */
-export function defaultRustSourceRange(): RustSourceRange {
-  return [0, 0, 0]
+export function topLevelRange(start: number, end: number): SourceRange {
+  return [start, end, 0]
+}
+
+/**
+ * Returns true if this source range is from the file being executed.  Returns
+ * false if it's from a file that was imported.
+ */
+export function isTopLevelModule(range: SourceRange): boolean {
+  return range[2] === 0
 }
 
 export const wasmUrl = () => {
@@ -234,7 +248,8 @@ export const parse = (code: string | Error): ParseResult | Error => {
       parsed.msg,
       sourceRangeFromRust(parsed.sourceRanges[0]),
       [],
-      []
+      [],
+      defaultArtifactGraph()
     )
   }
 }
@@ -258,8 +273,9 @@ export const isPathToNodeNumber = (
 export interface ExecState {
   memory: ProgramMemory
   operations: Operation[]
-  artifacts: { [key in ArtifactId]?: Artifact }
+  artifacts: { [key in ArtifactId]?: RustArtifact }
   artifactCommands: ArtifactCommand[]
+  artifactGraph: ArtifactGraph
 }
 
 /**
@@ -272,18 +288,53 @@ export function emptyExecState(): ExecState {
     operations: [],
     artifacts: {},
     artifactCommands: [],
+    artifactGraph: defaultArtifactGraph(),
   }
 }
 
-function execStateFromRust(execOutcome: RustExecOutcome): ExecState {
+function execStateFromRust(
+  execOutcome: RustExecOutcome,
+  program: Node<Program>
+): ExecState {
+  const artifactGraph = rustArtifactGraphToMap(execOutcome.artifactGraph)
+  // We haven't ported pathToNode logic to Rust yet, so we need to fill it in.
+  for (const [id, artifact] of artifactGraph) {
+    if (!artifact) continue
+    if (!('codeRef' in artifact)) continue
+    const pathToNode = getNodePathFromSourceRange(
+      program,
+      sourceRangeFromRust(artifact.codeRef.range)
+    )
+    artifact.codeRef.pathToNode = pathToNode
+  }
+
   return {
     memory: ProgramMemory.fromRaw(execOutcome.memory),
     operations: execOutcome.operations,
     artifacts: execOutcome.artifacts,
     artifactCommands: execOutcome.artifactCommands,
+    artifactGraph,
   }
 }
 
+export type ArtifactGraph = Map<ArtifactId, Artifact>
+
+function rustArtifactGraphToMap(
+  rustArtifactGraph: RustArtifactGraph
+): ArtifactGraph {
+  const map = new Map<ArtifactId, Artifact>()
+  for (const [id, artifact] of Object.entries(rustArtifactGraph.map)) {
+    if (!artifact) continue
+    map.set(id, artifact)
+  }
+
+  return map
+}
+
+export function defaultArtifactGraph(): ArtifactGraph {
+  return new Map()
+}
+
 interface Memory {
   [key: string]: KclValue | undefined
 }
@@ -543,7 +594,7 @@ export const executor = async (
       engineCommandManager,
       fileSystemManager
     )
-    return execStateFromRust(execOutcome)
+    return execStateFromRust(execOutcome, node)
   } catch (e: any) {
     console.log(e)
     const parsed: KclErrorWithOutputs = JSON.parse(e.toString())
@@ -552,7 +603,8 @@ export const executor = async (
       parsed.error.msg,
       sourceRangeFromRust(parsed.error.sourceRanges[0]),
       parsed.operations,
-      parsed.artifactCommands
+      parsed.artifactCommands,
+      rustArtifactGraphToMap(parsed.artifactGraph)
     )
 
     return Promise.reject(kclError)
@@ -613,7 +665,8 @@ export const modifyAstForSketch = async (
       parsed.msg,
       sourceRangeFromRust(parsed.sourceRanges[0]),
       [],
-      []
+      [],
+      defaultArtifactGraph()
     )
 
     console.log(kclError)
@@ -683,7 +736,8 @@ export function programMemoryInit(): ProgramMemory | Error {
       parsed.msg,
       sourceRangeFromRust(parsed.sourceRanges[0]),
       [],
-      []
+      [],
+      defaultArtifactGraph()
     )
   }
 }

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -9,7 +9,11 @@ import { Selections } from 'lib/selections'
 import { kclManager } from 'lib/singletons'
 import { err } from 'lib/trap'
 import { modelingMachine, SketchTool } from 'machines/modelingMachine'
-import { loftValidator, revolveAxisValidator } from './validators'
+import {
+  loftValidator,
+  revolveAxisValidator,
+  shellValidator,
+} from './validators'
 
 type OutputFormat = Models['OutputFormat_type']
 type OutputTypeKey = OutputFormat['type']
@@ -56,10 +60,13 @@ export type ModelingCommandSchema = {
     edge: Selections
   }
   Fillet: {
-    // todo
     selection: Selections
     radius: KclCommandValue
   }
+  Chamfer: {
+    selection: Selections
+    length: KclCommandValue
+  }
   'Offset plane': {
     plane: Selections
     distance: KclCommandValue
@@ -273,7 +280,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
     args: {
       selection: {
         inputType: 'selection',
-        selectionTypes: ['solid2D', 'segment'],
+        selectionTypes: ['solid2d', 'segment'],
         multiple: false, // TODO: multiple selection
         required: true,
         skip: true,
@@ -305,7 +312,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
     args: {
       profile: {
         inputType: 'selection',
-        selectionTypes: ['solid2D'],
+        selectionTypes: ['solid2d'],
         required: true,
         skip: true,
         multiple: false,
@@ -326,11 +333,11 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
   Loft: {
     description: 'Create a 3D body by blending between two or more sketches',
     icon: 'loft',
-    needsReview: true,
+    needsReview: false,
     args: {
       selection: {
         inputType: 'selection',
-        selectionTypes: ['solid2D'],
+        selectionTypes: ['solid2d'],
         multiple: true,
         required: true,
         skip: false,
@@ -348,12 +355,13 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
         selectionTypes: ['cap', 'wall'],
         multiple: true,
         required: true,
-        skip: false,
+        validation: shellValidator,
       },
       thickness: {
         inputType: 'kcl',
         defaultValue: KCL_DEFAULT_LENGTH,
         required: true,
+        // TODO: add dry-run validation on thickness param
       },
     },
   },
@@ -365,7 +373,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
     args: {
       selection: {
         inputType: 'selection',
-        selectionTypes: ['solid2D', 'segment'],
+        selectionTypes: ['solid2d', 'segment'],
         multiple: false, // TODO: multiple selection
         required: true,
         skip: true,
@@ -429,7 +437,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
   },
   Fillet: {
     description: 'Fillet edge',
-    icon: 'fillet',
+    icon: 'fillet3d',
     status: 'development',
     needsReview: true,
     args: {
@@ -449,6 +457,28 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
       },
     },
   },
+  Chamfer: {
+    description: 'Chamfer edge',
+    icon: 'chamfer3d',
+    status: 'development',
+    needsReview: true,
+    args: {
+      selection: {
+        inputType: 'selection',
+        selectionTypes: ['segment', 'sweepEdge', 'edgeCutEdge'],
+        multiple: true,
+        required: true,
+        skip: false,
+        warningMessage:
+          'Chamfers cannot touch other chamfers yet. This is under development.',
+      },
+      length: {
+        inputType: 'kcl',
+        defaultValue: KCL_DEFAULT_LENGTH,
+        required: true,
+      },
+    },
+  },
   'Constrain length': {
     description: 'Constrain the length of one or more segments.',
     icon: 'dimension',
@@ -548,7 +578,7 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
       selection: {
         inputType: 'selection',
         selectionTypes: [
-          'solid2D',
+          'solid2d',
           'segment',
           'sweepEdge',
           'cap',

src/lib/commandBarConfigs/projectsCommandConfig.ts

@@ -63,12 +63,11 @@ export const projectsCommandBarConfig: StateMachineCommandSetConfig<
       name: {
         inputType: 'options',
         required: true,
-        options: [],
-        optionsFromContext: (context) =>
-          context.projects.map((p) => ({
+        options: (_, context) =>
+          context?.projects.map((p) => ({
             name: p.name!,
             value: p.name!,
-          })),
+          })) || [],
       },
     },
   },
@@ -80,12 +79,11 @@ export const projectsCommandBarConfig: StateMachineCommandSetConfig<
       oldName: {
         inputType: 'options',
         required: true,
-        options: [],
-        optionsFromContext: (context) =>
-          context.projects.map((p) => ({
+        options: (_, context) =>
+          context?.projects.map((p) => ({
             name: p.name!,
             value: p.name!,
-          })),
+          })) || [],
       },
       newName: {
         inputType: 'string',

src/lib/commandBarConfigs/validators.ts

@@ -116,16 +116,16 @@ export const loftValidator = async ({
   }
   const { selection } = data
 
-  if (selection.graphSelections.some((s) => s.artifact?.type !== 'solid2D')) {
-    return 'Unable to loft, some selection are not solid2Ds'
+  if (selection.graphSelections.some((s) => s.artifact?.type !== 'solid2d')) {
+    return 'Unable to loft, some selection are not solid2ds'
   }
 
   const sectionIds = data.selection.graphSelections.flatMap((s) =>
-    s.artifact?.type === 'solid2D' ? s.artifact.pathId : []
+    s.artifact?.type === 'solid2d' ? s.artifact.pathId : []
   )
 
   if (sectionIds.length < 2) {
-    return 'Unable to loft, selection contains less than two solid2Ds'
+    return 'Unable to loft, selection contains less than two solid2ds'
   }
 
   const loftCommand = async () => {
@@ -153,3 +153,57 @@ export const loftValidator = async ({
     return 'Unable to loft with selected sketches'
   }
 }
+
+export const shellValidator = async ({
+  data,
+}: {
+  data: { selection: Selections }
+}): Promise<boolean | string> => {
+  if (!isSelections(data.selection)) {
+    return 'Unable to shell, selections are missing'
+  }
+
+  // No validation on the faces, filtering is done upstream and we have the dry run validation just below
+  const face_ids = data.selection.graphSelections.flatMap((s) =>
+    s.artifact ? s.artifact.id : []
+  )
+
+  // We don't have the concept of solid3ds in TS yet.
+  // So we're listing out the sweeps as if they were solids and taking the first one, just like in Rust for Shell:
+  // https://github.com/KittyCAD/modeling-app/blob/e61fff115b9fa94aaace6307b1842cc15d41655e/src/wasm-lib/kcl/src/std/shell.rs#L237-L238
+  // TODO: This is one cheap way to make sketch-on-face supported now but will likely fail multiple solids
+  const object_id = engineCommandManager.artifactGraph
+    .values()
+    .find((v) => v.type === 'sweep')?.pathId
+
+  if (!object_id) {
+    return "Unable to shell, couldn't find the solid"
+  }
+
+  const shellCommand = async () => {
+    // TODO: figure out something better than an arbitrarily small value
+    const DEFAULT_THICKNESS: Models['LengthUnit_type'] = 1e-9
+    const DEFAULT_HOLLOW = false
+    const cmdArgs = {
+      face_ids,
+      object_id,
+      hollow: DEFAULT_HOLLOW,
+      shell_thickness: DEFAULT_THICKNESS,
+    }
+    return await engineCommandManager.sendSceneCommand({
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'solid3d_shell_face',
+        ...cmdArgs,
+      },
+    })
+  }
+
+  const attemptShell = await dryRunWrapper(shellCommand)
+  if (attemptShell?.success) {
+    return true
+  }
+
+  return 'Unable to shell with the provided selection'
+}

src/lib/commandTypes.ts

@@ -76,6 +76,7 @@ export type Command<
     | ((
         commandBarContext: { argumentsToSubmit: Record<string, unknown> } // Should be the commandbarMachine's context, but it creates a circular dependency
       ) => string | ReactNode)
+  machineActor?: Actor<T>
   onSubmit: (data?: CommandSchema) => void
   onCancel?: () => void
   args?: {
@@ -95,7 +96,7 @@ export type CommandConfig<
   Command<T, CommandName, CommandSchema>,
   'name' | 'groupId' | 'onSubmit' | 'onCancel' | 'args' | 'needsReview'
 > & {
-  needsReview?: true
+  needsReview?: boolean
   status?: 'active' | 'development' | 'inactive'
   args?: {
     [ArgName in keyof CommandSchema]: CommandArgumentConfig<

src/lib/commandUtils.test.ts

@@ -0,0 +1,49 @@
+import { CommandWithDisabledState, sortCommands } from './commandUtils'
+
+function commandWithDisabled(
+  name: string,
+  disabled: boolean,
+  groupId = 'modeling'
+): CommandWithDisabledState {
+  return {
+    command: {
+      name,
+      groupId,
+      needsReview: false,
+      onSubmit: () => {},
+    },
+    disabled,
+  }
+}
+
+describe('Command sorting', () => {
+  it(`Puts modeling commands first`, () => {
+    const initial = [
+      commandWithDisabled('a', false, 'settings'),
+      commandWithDisabled('b', false, 'modeling'),
+      commandWithDisabled('c', false, 'settings'),
+    ]
+    const sorted = initial.sort(sortCommands)
+    expect(sorted[0].command.groupId).toBe('modeling')
+  })
+
+  it(`Puts disabled commands last`, () => {
+    const initial = [
+      commandWithDisabled('a', true, 'modeling'),
+      commandWithDisabled('z', false, 'modeling'),
+      commandWithDisabled('a', false, 'settings'),
+    ]
+    const sorted = initial.sort(sortCommands)
+    expect(sorted[sorted.length - 1].disabled).toBe(true)
+  })
+
+  it(`Puts settings commands second to last`, () => {
+    const initial = [
+      commandWithDisabled('a', true, 'modeling'),
+      commandWithDisabled('z', false, 'modeling'),
+      commandWithDisabled('a', false, 'settings'),
+    ]
+    const sorted = initial.sort(sortCommands)
+    expect(sorted[1].command.groupId).toBe('settings')
+  })
+})

src/lib/commandUtils.ts

@@ -2,6 +2,9 @@
 // That object also contains some metadata about what to do with the KCL expression,
 // such as whether we need to create a new variable for it.
 // This function extracts the value field from those arg payloads and returns
+
+import { Command } from './commandTypes'
+
 // The arg object with all its field as natural values that the command to be executed will expect.
 export function getCommandArgumentKclValuesOnly(args: Record<string, unknown>) {
   return Object.fromEntries(
@@ -13,3 +16,42 @@ export function getCommandArgumentKclValuesOnly(args: Record<string, unknown>) {
     })
   )
 }
+
+export interface CommandWithDisabledState {
+  command: Command
+  disabled: boolean
+}
+
+/**
+ * Sorting logic for commands in the command combo box.
+ */
+export function sortCommands(
+  a: CommandWithDisabledState,
+  b: CommandWithDisabledState
+) {
+  // Disabled commands should be at the bottom
+  if (a.disabled && !b.disabled) {
+    return 1
+  }
+  if (b.disabled && !a.disabled) {
+    return -1
+  }
+  // Settings commands should be next-to-last
+  if (a.command.groupId === 'settings' && b.command.groupId !== 'settings') {
+    return 1
+  }
+  if (b.command.groupId === 'settings' && a.command.groupId !== 'settings') {
+    return -1
+  }
+  // Modeling commands should be first
+  if (a.command.groupId === 'modeling' && b.command.groupId !== 'modeling') {
+    return -1
+  }
+  if (b.command.groupId === 'modeling' && a.command.groupId !== 'modeling') {
+    return 1
+  }
+  // Sort alphabetically
+  return (a.command.displayName || a.command.name).localeCompare(
+    b.command.displayName || b.command.name
+  )
+}

src/lib/createMachineCommand.ts

@@ -96,6 +96,7 @@ export function createMachineCommand<
     icon,
     description: commandConfig.description,
     needsReview: commandConfig.needsReview || false,
+    machineActor: actor,
     onSubmit: (data?: S[typeof type]) => {
       if (data !== undefined && data !== null) {
         send({ type, data })

src/lib/desktopFS.test.ts

@@ -0,0 +1,58 @@
+import { getUniqueProjectName } from './desktopFS'
+import { FileEntry } from './project'
+
+/** Create a dummy project */
+function project(name: string, children?: FileEntry[]): FileEntry {
+  return {
+    name,
+    children: children || [
+      { name: 'main.kcl', children: null, path: 'main.kcl' },
+    ],
+    path: `/projects/${name}`,
+  }
+}
+
+describe(`Getting unique project names`, () => {
+  it(`should return the same name if no conflicts`, () => {
+    const projectName = 'new-project'
+    const projects = [project('existing-project'), project('another-project')]
+    const result = getUniqueProjectName(projectName, projects)
+    expect(result).toBe(projectName)
+  })
+  it(`should return a unique name if there is a conflict`, () => {
+    const projectName = 'existing-project'
+    const projects = [project('existing-project'), project('another-project')]
+    const result = getUniqueProjectName(projectName, projects)
+    expect(result).toBe('existing-project-1')
+  })
+  it(`should increment an ending index until a unique one is found`, () => {
+    const projectName = 'existing-project-1'
+    const projects = [
+      project('existing-project'),
+      project('existing-project-1'),
+      project('existing-project-2'),
+    ]
+    const result = getUniqueProjectName(projectName, projects)
+    expect(result).toBe('existing-project-3')
+  })
+  it(`should prefer the formatting of the index identifier if present`, () => {
+    const projectName = 'existing-project-$nn'
+    const projects = [
+      project('existing-project'),
+      project('existing-project-1'),
+      project('existing-project-2'),
+    ]
+    const result = getUniqueProjectName(projectName, projects)
+    expect(result).toBe('existing-project-03')
+  })
+  it(`be able to get an incrementing index regardless of padding zeroes`, () => {
+    const projectName = 'existing-project-$nn'
+    const projects = [
+      project('existing-project'),
+      project('existing-project-01'),
+      project('existing-project-2'),
+    ]
+    const result = getUniqueProjectName(projectName, projects)
+    expect(result).toBe('existing-project-03')
+  })
+})

src/lib/desktopFS.ts

@@ -54,8 +54,10 @@ export function getNextProjectIndex(
   const matches = projects.map((project) => project.name?.match(regex))
   const indices = matches
     .filter(Boolean)
-    .map((match) => match![1])
-    .map(Number)
+    .map((match) => (match !== null ? match[1] : '-1'))
+    .map((maybeMatchIndex) => {
+      return parseInt(maybeMatchIndex || '0', 10)
+    })
   const maxIndex = Math.max(...indices, -1)
   return maxIndex + 1
 }
@@ -83,6 +85,33 @@ export function doesProjectNameNeedInterpolated(projectName: string) {
   return projectName.includes(INDEX_IDENTIFIER)
 }
 
+/**
+ * Given a target name, which may include our magic index interpolation string,
+ * and a list of projects, return a unique name that doesn't conflict with any
+ * of the existing projects, incrementing any ending number if necessary.
+ * @param name
+ * @param projects
+ * @returns
+ */
+export function getUniqueProjectName(name: string, projects: FileEntry[]) {
+  // The name may have our magic index interpolation string in it
+  const needsInterpolation = doesProjectNameNeedInterpolated(name)
+
+  if (needsInterpolation) {
+    const nextIndex = getNextProjectIndex(name, projects)
+    return interpolateProjectNameWithIndex(name, nextIndex)
+  } else {
+    let newName = name
+    while (projects.some((project) => project.name === newName)) {
+      const nameEndsWithNumber = newName.match(/\d+$/)
+      newName = nameEndsWithNumber
+        ? newName.replace(/\d+$/, (num) => `${parseInt(num, 10) + 1}`)
+        : `${name}-1`
+    }
+    return newName
+  }
+}
+
 function escapeRegExpChars(string: string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
 }