Fix error: unknown sketch function circle (#6012 )

Feature: Traditional menu actions in desktop application (#5892 )
* chore: skeleton for building and creating menus. Need electron to renderer interface to dynamically set the menu * chore: skeleton typing for communication between nodes and web side * chore: more skeleton for the different roles within the menu options, need more type safety * chore: adding more skeleton and templates of what the menus could be * chore: implemented first pass for helpRole links * fix: syntax issue stopped the build step * feature: loading different menus based on your page * feature: Home page file role implemented * chore: handling the build workflow for the signin page * fix: moving edit actionst to the edit menu * chore: adding preferences to the file role * chore: redoing help roles based on the question mark widget * fix: auto fmt * chore: examples of accelerator strings for Menu.MenuItems keyboard shortcuts! * chore: oddly specific toggle API for disabling MenuItems from JS. No rules! * fix: do not implement a custom label disable thingy, use id on menu and use the native APIga * fix: auto fmt * fix: adding some typechecks and auto fmt fixes * fix: trying to fix custom type? * fix: nvm we back, the lsp on my editor borked for a second * fix: adding one more level to the custom type for the labels * chore: cleaning up type definitions to read easier * fix: resolving yarn lint errors * chore: adding file sign out * chore: adding more file bar actions * chore: ready for PR draft * fix: preemptive GC collectoin bug fix if somehow a user interacts with a menu while it is being GCed * fix: linking the OG source * fix: set application menu to null to avoid default electron menu * chore: trying to add more typescript * chore: BIG workflow changes... better typing, less IPC junk * fix: remapping the icp functions to the cb option select... * chore: all og events are rehooked up with new workflow pattern * feat: adding more options to the native bar! * fix: todo * chore: cleaning up some menus and adding more * fix: desktop vs browser and lint errors * fix: typescript did not like sample electorn JS code for the basic templates with isMac conditionals... * fix: PR clean up * fix: more PR cleanup * A snapshot a day keeps the bugs away! 📷🐛 * fix: added the new help menu to the default sign in and modeling page * fix: disabled two menu actions within sign in page since they will not do anything. * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: mergining main, auto fixes * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: fixed ipc renderer off/remove listener bug * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: report a bug to refresha and report a bug * fix: new type for webContents send payload that does not brick TS * fix: removing import file from url since it is not working in the command palette for manual user input * fix: removing old comment * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * chore: adding some E2E tests. * chore: added E2E tests for each file menu * fix: auto fixes * chore: adding more edit role E2E tests * chore: e2e test * chore: adding help role e2e test * A snapshot a day keeps the bugs away! 📷🐛 * chore: e2e test for all the menu options you can interact with in the frontend --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
2025-03-26 14:04:59 -04:00 · 2025-03-26 13:03:44 -05:00 · 2025-03-26 17:12:20 +00:00 · 2025-03-26 16:12:35 +00:00 · 2025-03-26 11:53:34 -04:00 · 2025-03-26 15:52:32 +00:00
260 changed files with 27820 additions and 25377 deletions
--- a/.github/workflows/update-e2e-branch.yml
+++ b/.github/workflows/update-e2e-branch.yml
@ -28,12 +28,18 @@ jobs:

      - name: Sync with main
        run: |
-          # checkout our branch
+          # Create the branch
          git checkout all-e2e || git checkout -b all-e2e
-          # fetch origin
+
+          # Reset to main
          git fetch origin
-          # reset to main
          git reset --hard origin/main
-          # force push it
+
+          # Get a new SHA to prevent overwriting the commit status on main
+          git config --local user.email "github-actions[bot]@users.noreply.github.com"
+          git config --local user.name "github-actions[bot]"
+          git commit --amend --message="[all-e2e] $(git log --max-count=1 --pretty=%B)"
+
+          # Overwrite the branch
          git remote set-url origin https://x-access-token:${{ steps.app-token.outputs.token }}@github.com/${{ github.repository }}.git
          git push --force origin all-e2e
--- a/e2e/playwright/code-pane-and-errors.spec.ts
+++ b/e2e/playwright/code-pane-and-errors.spec.ts
@ -21,14 +21,15 @@ test.describe('Code pane and errors', { tag: ['@skipWin'] }, () => {
    await page.addInitScript(() => {
      localStorage.setItem(
        'persistCode',
-        `// Extruded Triangle
-  sketch001 = startSketchOn(XZ)
-    |> startProfileAt([0, 0], %)
-    |> line(end = [10, 0])
-    |> line(end = [-5, 10])
-    |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
-    |> close()
-  extrude001 = extrude(sketch001, length = 5)`
+        `@settings(defaultLengthUnit = in)
+// Extruded Triangle
+sketch001 = startSketchOn(XZ)
+  |> startProfileAt([0, 0], %)
+  |> line(end = [10, 0])
+  |> line(end = [-5, 10])
+  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
+  |> close()
+extrude001 = extrude(sketch001, length = 5)`
      )
    })

--- a/e2e/playwright/named-views.spec.ts
+++ b/e2e/playwright/named-views.spec.ts
@ -0,0 +1,292 @@
+import { test, expect } from './zoo-test'
+import { PROJECT_SETTINGS_FILE_NAME } from 'lib/constants'
+import * as fsp from 'fs/promises'
+import { join } from 'path'
+import {
+  createProject,
+  tomlToPerProjectSettings,
+  perProjectsettingsToToml,
+} from './test-utils'
+import { NamedView } from '@rust/kcl-lib/bindings/NamedView'
+
+// Helper function to determine if the file path on disk exists
+// Specifically this is used to check if project.toml exists on disk
+const fileExists = async (path: string) => {
+  return !!(await fsp
+    .stat(path)
+    .then((_) => true)
+    .catch((_) => false))
+}
+
+// Here are a few uuids.
+// When created named views rust will auto generate uuids and they will
+// never match the snapshots. Overwrite them in memory to these
+// values to have them match the snapshots.
+const uuid1: string = '0656fb1a-9640-473e-b334-591dc70c0138'
+const uuid2: string = 'c810cf04-c6cc-4a4a-8b11-17bf445dcab7'
+const uuid3: string = 'cfecbfee-48a6-4561-b96d-ffbe5678bb7d'
+
+// Look up the named view by name and then rewrite it with the same uuid each time
+const nameToUuid: Map<string, string> = new Map()
+nameToUuid.set('uuid1', uuid1)
+nameToUuid.set('uuid2', uuid2)
+nameToUuid.set('uuid3', uuid3)
+
+/**
+ * Given the project.toml string, overwrite the named views to be the constant uuid
+ * values to match the snapshots. The uuids are randomly generated
+ */
+function tomlStringOverWriteNamedViewUuids(toml: string): string {
+  const settings = tomlToPerProjectSettings(toml)
+  const namedViews = settings.settings?.app?.named_views
+  if (namedViews) {
+    const entries = Object.entries(namedViews)
+    const remappedNamedViews: { [key: string]: NamedView } = {}
+    entries.forEach(([_, value]) => {
+      if (value) {
+        // {name:'uuid1'} -> uuid1 lookup
+        const staticUuid = nameToUuid.get(value.name)
+        if (staticUuid) {
+          remappedNamedViews[staticUuid] = value
+        }
+      }
+    })
+    if (settings && settings.settings && settings.settings.app) {
+      settings.settings.app.named_views = remappedNamedViews
+    }
+  }
+  return perProjectsettingsToToml(settings)
+}
+
+test.describe('Named view tests', () => {
+  test('Verify project.toml is not created', async ({ page }, testInfo) => {
+    // Create project and load it
+    const projectName = 'named-views'
+    await createProject({ name: projectName, page })
+
+    // Generate file paths for project.toml
+    const projectDirName = testInfo.outputPath('electron-test-projects-dir')
+    const tempProjectSettingsFilePath = join(
+      projectDirName,
+      projectName,
+      PROJECT_SETTINGS_FILE_NAME
+    )
+
+    // project.toml should not exist on initial project creation
+    let exists = await fileExists(tempProjectSettingsFilePath)
+    expect(exists).toBe(false)
+  })
+  test('Verify named view gets created', async ({
+    cmdBar,
+    scene,
+    page,
+  }, testInfo) => {
+    const projectName = 'named-views'
+    const myNamedView = 'uuid1'
+
+    // Create and load project
+    await createProject({ name: projectName, page })
+    await scene.waitForExecutionDone()
+
+    // Create named view
+    const projectDirName = testInfo.outputPath('electron-test-projects-dir')
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('create named view')
+    await cmdBar.argumentInput.fill(myNamedView)
+    await cmdBar.progressCmdBar(false)
+
+    // Generate paths for the project.toml
+    const tempProjectSettingsFilePath = join(
+      projectDirName,
+      projectName,
+      PROJECT_SETTINGS_FILE_NAME
+    )
+
+    // Expect project.toml to be generated on disk since a named view was created
+    await expect(async () => {
+      let exists = await fileExists(tempProjectSettingsFilePath)
+      expect(exists).toBe(true)
+    }).toPass()
+
+    // Read project.toml into memory
+    let tomlString = await fsp.readFile(tempProjectSettingsFilePath, 'utf-8')
+    // Rewrite the uuids in the named views to match snapshot otherwise they will be randomly generated from rust and break
+    tomlString = tomlStringOverWriteNamedViewUuids(tomlString)
+
+    // Write the entire tomlString to a snapshot.
+    // There are many key/value pairs to check this is a safer match.
+    expect(tomlString).toMatchSnapshot('verify-named-view-gets-created')
+  })
+  test('Verify named view gets deleted', async ({
+    cmdBar,
+    scene,
+    page,
+  }, testInfo) => {
+    const projectName = 'named-views'
+    const myNamedView1 = 'uuid1'
+    const myNamedView2 = 'uuid2'
+
+    // Create project and go into the project
+    await createProject({ name: projectName, page })
+    await scene.waitForExecutionDone()
+
+    // Create a new named view
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('create named view')
+    await cmdBar.argumentInput.fill(myNamedView1)
+    await cmdBar.progressCmdBar(false)
+
+    // Generate file paths for project.toml
+    const projectDirName = testInfo.outputPath('electron-test-projects-dir')
+    const tempProjectSettingsFilePath = join(
+      projectDirName,
+      projectName,
+      PROJECT_SETTINGS_FILE_NAME
+    )
+
+    // Except the project.toml to be written to disk since a named view was created
+    await expect(async () => {
+      let exists = await fileExists(tempProjectSettingsFilePath)
+      expect(exists).toBe(true)
+    }).toPass()
+
+    // Read project.toml into memory
+    let tomlString = await fsp.readFile(tempProjectSettingsFilePath, 'utf-8')
+    // Rewrite the uuids in the named views to match snapshot otherwise they will be randomly generated from rust and break
+    tomlString = tomlStringOverWriteNamedViewUuids(tomlString)
+
+    // Write the entire tomlString to a snapshot.
+    // There are many key/value pairs to check this is a safer match.
+    expect(tomlString).toMatchSnapshot('verify-named-view-gets-created')
+
+    // Delete a named view
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('delete named view')
+    cmdBar.selectOption({ name: myNamedView2 })
+    await cmdBar.progressCmdBar(false)
+
+    // Read project.toml into memory again since we deleted a named view
+    tomlString = await fsp.readFile(tempProjectSettingsFilePath, 'utf-8')
+    // Rewrite the uuids in the named views to match snapshot otherwise they will be randomly generated from rust and break
+    tomlString = tomlStringOverWriteNamedViewUuids(tomlString)
+
+    // // Write the entire tomlString to a snapshot.
+    // // There are many key/value pairs to check this is a safer match.
+    expect(tomlString).toMatchSnapshot('verify-named-view-gets-deleted')
+  })
+  test('Verify named view gets loaded', async ({
+    cmdBar,
+    scene,
+    page,
+  }, testInfo) => {
+    const projectName = 'named-views'
+    const myNamedView = 'uuid1'
+
+    // Create project and go into the project
+    await createProject({ name: projectName, page })
+    await scene.waitForExecutionDone()
+
+    // Create a new named view
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('create named view')
+    await cmdBar.argumentInput.fill(myNamedView)
+    await cmdBar.progressCmdBar(false)
+
+    // Generate file paths for project.toml
+    const projectDirName = testInfo.outputPath('electron-test-projects-dir')
+    const tempProjectSettingsFilePath = join(
+      projectDirName,
+      projectName,
+      PROJECT_SETTINGS_FILE_NAME
+    )
+
+    // Except the project.toml to be written to disk since a named view was created
+    await expect(async () => {
+      let exists = await fileExists(tempProjectSettingsFilePath)
+      expect(exists).toBe(true)
+    }).toPass()
+
+    // Read project.toml into memory
+    let tomlString = await fsp.readFile(tempProjectSettingsFilePath, 'utf-8')
+    // Rewrite the uuids in the named views to match snapshot otherwise they will be randomly generated from rust and break
+    tomlString = tomlStringOverWriteNamedViewUuids(tomlString)
+
+    // Write the entire tomlString to a snapshot.
+    // There are many key/value pairs to check this is a safer match.
+    expect(tomlString).toMatchSnapshot('verify-named-view-gets-created')
+
+    // Create a load a named view
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('load named view')
+    await cmdBar.argumentInput.fill(myNamedView)
+    await cmdBar.progressCmdBar(false)
+
+    // Check the toast appeared
+    await expect(
+      page.getByText(`Named view ${myNamedView} loaded.`)
+    ).toBeVisible()
+  })
+  test('Verify two named views get created', async ({
+    cmdBar,
+    scene,
+    page,
+  }, testInfo) => {
+    const projectName = 'named-views'
+    const myNamedView1 = 'uuid1'
+    const myNamedView2 = 'uuid2'
+
+    // Create and load project
+    await createProject({ name: projectName, page })
+    await scene.waitForExecutionDone()
+
+    // Create named view
+    const projectDirName = testInfo.outputPath('electron-test-projects-dir')
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('create named view')
+    await cmdBar.argumentInput.fill(myNamedView1)
+    await cmdBar.progressCmdBar(false)
+
+    await page.waitForTimeout(1000)
+
+    const orbitMouseStart = { x: 800, y: 130 }
+    const orbitMouseEnd = { x: 0, y: 130 }
+    await page.mouse.move(orbitMouseStart.x, orbitMouseStart.y)
+    await page.mouse.down({ button: 'middle' })
+    await page.mouse.move(orbitMouseEnd.x, orbitMouseEnd.y, {
+      steps: 3,
+    })
+    await page.mouse.up({ button: 'middle' })
+
+    await page.waitForTimeout(1000)
+
+    await cmdBar.openCmdBar()
+    await cmdBar.chooseCommand('create named view')
+    await cmdBar.argumentInput.fill(myNamedView2)
+    await cmdBar.progressCmdBar(false)
+
+    // Wait a moment for the project.toml to get written to disk with the new view point
+    await page.waitForTimeout(1000)
+
+    // Generate paths for the project.toml
+    const tempProjectSettingsFilePath = join(
+      projectDirName,
+      projectName,
+      PROJECT_SETTINGS_FILE_NAME
+    )
+
+    // Expect project.toml to be generated on disk since a named view was created
+    await expect(async () => {
+      let exists = await fileExists(tempProjectSettingsFilePath)
+      expect(exists).toBe(true)
+    }).toPass()
+
+    // Read project.toml into memory
+    let tomlString = await fsp.readFile(tempProjectSettingsFilePath, 'utf-8')
+    // Rewrite the uuids in the named views to match snapshot otherwise they will be randomly generated from rust and break
+    tomlString = tomlStringOverWriteNamedViewUuids(tomlString)
+
+    // Write the entire tomlString to a snapshot.
+    // There are many key/value pairs to check this is a safer match.
+    expect(tomlString).toMatchSnapshot('verify-two-named-view-gets-created')
+  })
+})
--- a/e2e/playwright/named-views.spec.ts-snapshots/verify-named-view-gets-created-chromium-linux
+++ b/e2e/playwright/named-views.spec.ts-snapshots/verify-named-view-gets-created-chromium-linux
@ -0,0 +1,16 @@
+[settings]
+modeling = { }
+text_editor = { }
+command_bar = { }
+
+[settings.app.named_views.0656fb1a-9640-473e-b334-591dc70c0138]
+name = "uuid1"
+eye_offset = 1_378.0059
+fov_y = 45
+is_ortho = false
+ortho_scale_enabled = true
+ortho_scale_factor = 1.6
+pivot_position = [ 0, 0, 0 ]
+pivot_rotation = [ 0.5380994, 0.0, 0.0, 0.8428814 ]
+world_coord_system = "right_handed_up_z"
+version = 1
--- a/e2e/playwright/named-views.spec.ts-snapshots/verify-named-view-gets-deleted-chromium-linux
+++ b/e2e/playwright/named-views.spec.ts-snapshots/verify-named-view-gets-deleted-chromium-linux
@ -0,0 +1,16 @@
+[settings]
+modeling = { }
+text_editor = { }
+command_bar = { }
+
+[settings.app.named_views.0656fb1a-9640-473e-b334-591dc70c0138]
+name = "uuid1"
+eye_offset = 1_378.0059
+fov_y = 45
+is_ortho = false
+ortho_scale_enabled = true
+ortho_scale_factor = 1.6
+pivot_position = [ 0, 0, 0 ]
+pivot_rotation = [ 0.5380994, 0.0, 0.0, 0.8428814 ]
+world_coord_system = "right_handed_up_z"
+version = 1
--- a/e2e/playwright/named-views.spec.ts-snapshots/verify-two-named-view-gets-created-chromium-linux
+++ b/e2e/playwright/named-views.spec.ts-snapshots/verify-two-named-view-gets-created-chromium-linux
@ -0,0 +1,28 @@
+[settings]
+modeling = { }
+text_editor = { }
+command_bar = { }
+
+[settings.app.named_views.0656fb1a-9640-473e-b334-591dc70c0138]
+name = "uuid1"
+eye_offset = 1_378.0059
+fov_y = 45
+is_ortho = false
+ortho_scale_enabled = true
+ortho_scale_factor = 1.6
+pivot_position = [ 0, 0, 0 ]
+pivot_rotation = [ 0.5380994, 0.0, 0.0, 0.8428814 ]
+world_coord_system = "right_handed_up_z"
+version = 1
+
+[settings.app.named_views.c810cf04-c6cc-4a4a-8b11-17bf445dcab7]
+name = "uuid2"
+eye_offset = 1_378.0059
+fov_y = 45
+is_ortho = false
+ortho_scale_enabled = true
+ortho_scale_factor = 1.6
+pivot_position = [ 1_826.5239, 0.0, 0.0 ]
+pivot_rotation = [ 0.5380994, 0.0, 0.0, 0.8428814 ]
+world_coord_system = "right_handed_up_z"
+version = 1
--- a/e2e/playwright/native-file-menu.spec.ts
+++ b/e2e/playwright/native-file-menu.spec.ts
@ -0,0 +1,312 @@
+import { test, expect } from './zoo-test'
+
+/**
+ * Not all menu actions are tested. Some are default electron menu actions.
+ * Test file menu actions that trigger something in the frontend
+ */
+test.describe('Native file menu', { tag: ['@electron'] }, () => {
+  test.describe('Home page', () => {
+    test.describe('File role', () => {
+      test('File.Create project', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const newProject =
+            app.applicationMenu.getMenuItemById('File.New project')
+          if (!newProject) fail()
+          newProject.click()
+        })
+        // Check that the command bar is opened
+        await expect(cmdBar.cmdBarElement).toBeVisible()
+        // Check the placeholder project name exists
+        const actualArgument = await cmdBar.cmdBarElement
+          .getByTestId('cmd-bar-arg-value')
+          .inputValue()
+        const expectedArgument = 'project-$nnn'
+        expect(actualArgument).toBe(expectedArgument)
+      })
+      test('File.Open project', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const openProject =
+            app.applicationMenu.getMenuItemById('File.Open project')
+          if (!openProject) fail()
+          openProject.click()
+        })
+        // Check that the command bar is opened
+        await expect(cmdBar.cmdBarElement).toBeVisible()
+        // Check the placeholder project name exists
+        const actual = await cmdBar.cmdBarElement
+          .getByTestId('command-name')
+          .textContent()
+        const expected = 'Open project'
+        expect(actual).toBe(expected)
+      })
+      test('File.Preferences.User settings', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const userSettings = app.applicationMenu.getMenuItemById(
+            'File.Preferences.User settings'
+          )
+          if (!userSettings) fail()
+          userSettings.click()
+        })
+        const settings = page.getByTestId('settings-dialog-panel')
+        await expect(settings).toBeVisible()
+        // You are viewing the user tab
+        const actualText = settings.getByText(
+          'The overall appearance of the app'
+        )
+        await expect(actualText).toBeVisible()
+      })
+      test('File.Preferences.Keybindings', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const keybindings = app.applicationMenu.getMenuItemById(
+            'File.Preferences.Keybindings'
+          )
+          if (!keybindings) fail()
+          keybindings.click()
+        })
+        const settings = page.getByTestId('settings-dialog-panel')
+        await expect(settings).toBeVisible()
+        // You are viewing the keybindings tab
+        const enterSketchMode = settings.locator('#enter-sketch-mode')
+        await expect(enterSketchMode).toBeVisible()
+      })
+      test('File.Preferences.User default units', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'File.Preferences.User default units'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        const settings = page.getByTestId('settings-dialog-panel')
+        await expect(settings).toBeVisible()
+        const defaultUnit = settings.locator('#defaultUnit')
+        await expect(defaultUnit).toBeVisible()
+      })
+      test('File.Preferences.Theme', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'File.Preferences.Theme'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Check that the command bar is opened
+        await expect(cmdBar.cmdBarElement).toBeVisible()
+        // Check the placeholder project name exists
+        const actual = await cmdBar.cmdBarElement
+          .getByTestId('command-name')
+          .textContent()
+        const expected = 'Settings · app · theme'
+        expect(actual).toBe(expected)
+      })
+      test('File.Preferences.Theme color', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'File.Preferences.Theme color'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        const settings = page.getByTestId('settings-dialog-panel')
+        await expect(settings).toBeVisible()
+        const defaultUnit = settings.locator('#themeColor')
+        await expect(defaultUnit).toBeVisible()
+      })
+      test('File.Preferences.Sign out', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById('File.Sign out')
+          if (!menu) fail()
+          // FIXME: Add back when you can actually sign out
+          // menu.click()
+        })
+        // FIXME: When signing out during E2E the page is not bound correctly.
+        // It cannot find the button
+        // const signIn = page.getByTestId('sign-in-button')
+        // await expect(signIn).toBeVisible()
+      })
+    })
+
+    test.describe('Edit role', () => {
+      test('Edit.Rename project', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Edit.Rename project'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Check the placeholder project name exists
+        const actual = await cmdBar.cmdBarElement
+          .getByTestId('command-name')
+          .textContent()
+        const expected = 'Rename project'
+        expect(actual).toBe(expected)
+      })
+      test('Edit.Delete project', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Edit.Delete project'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Check the placeholder project name exists
+        const actual = await cmdBar.cmdBarElement
+          .getByTestId('command-name')
+          .textContent()
+        const expected = 'Delete project'
+        expect(actual).toBe(expected)
+      })
+      test('Edit.Change project directory', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Edit.Change project directory'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        const settings = page.getByTestId('settings-dialog-panel')
+        await expect(settings).toBeVisible()
+        const projectDirectory = settings.locator('#projectDirectory')
+        await expect(projectDirectory).toBeVisible()
+      })
+    })
+    test.describe('View role', () => {
+      test('View.Command Palette...', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'View.Command Palette...'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Check the placeholder project name exists
+        const actual = cmdBar.cmdBarElement.getByTestId('cmd-bar-search')
+        await expect(actual).toBeVisible()
+      })
+    })
+    test.describe('Help role', () => {
+      test('Help.Show all commands', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Help.Show all commands'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Check the placeholder project name exists
+        const actual = cmdBar.cmdBarElement.getByTestId('cmd-bar-search')
+        await expect(actual).toBeVisible()
+      })
+      test('Help.KCL code samples', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Help.KCL code samples'
+          )
+          if (!menu) fail()
+        })
+      })
+      test('Help.Refresh and report a bug', async ({
+        tronApp,
+        cmdBar,
+        page,
+      }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Help.Refresh and report a bug'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+        // Core dump and refresh magic number timeout
+        await page.waitForTimeout(7000)
+        const actual = page.getByText(
+          'No Projects found, ready to make your first one?'
+        )
+        await expect(actual).toBeVisible()
+      })
+      test('Help.Reset onboarding', async ({ tronApp, cmdBar, page }) => {
+        if (!tronApp) fail()
+        // Run electron snippet to find the Menu!
+        await tronApp.electron.evaluate(async ({ app }) => {
+          if (!app || !app.applicationMenu) fail()
+          const menu = app.applicationMenu.getMenuItemById(
+            'Help.Reset onboarding'
+          )
+          if (!menu) fail()
+          menu.click()
+        })
+
+        const actual = page.getByText(
+          `This is a hardware design tool that lets you edit visually, with code, or both. It's powered by the KittyCAD Design API, the first API created for anyone to build hardware design tools.`
+        )
+        await expect(actual).toBeVisible()
+      })
+    })
+  })
+})
--- a/e2e/playwright/point-click.spec.ts
+++ b/e2e/playwright/point-click.spec.ts
@ -1773,7 +1773,7 @@ extrude001 = extrude(sketch001, length = -12)
    const filletColor: [number, number, number] = [127, 127, 127]
    const backgroundColor: [number, number, number] = [30, 30, 30]
    const lowTolerance = 20
-    const highTolerance = 40
+    const highTolerance = 70 // TODO: understand why I needed that for edgeColorYellow on macos (local)

    // Setup
    await test.step(`Initial test setup`, async () => {
@ -1860,6 +1860,54 @@ extrude001 = extrude(sketch001, length = -12)
      await scene.expectPixelColor(filletColor, firstEdgeLocation, lowTolerance)
    })

+    // Test 1.1: Edit fillet (segment type)
+    async function editFillet(
+      featureTreeIndex: number,
+      oldValue: string,
+      newValue: string
+    ) {
+      await toolbar.openPane('feature-tree')
+      const operationButton = await toolbar.getFeatureTreeOperation(
+        'Fillet',
+        featureTreeIndex
+      )
+      await operationButton.dblclick({ button: 'left' })
+      await cmdBar.expectState({
+        commandName: 'Fillet',
+        currentArgKey: 'radius',
+        currentArgValue: oldValue,
+        headerArguments: {
+          Radius: oldValue,
+        },
+        highlightedHeaderArg: 'radius',
+        stage: 'arguments',
+      })
+      await page.keyboard.insertText(newValue)
+      await cmdBar.progressCmdBar()
+      await cmdBar.expectState({
+        stage: 'review',
+        headerArguments: {
+          Radius: newValue,
+        },
+        commandName: 'Fillet',
+      })
+      await cmdBar.progressCmdBar()
+      await toolbar.closePane('feature-tree')
+    }
+
+    await test.step('Edit fillet via feature tree selection works', async () => {
+      const firstFilletFeatureTreeIndex = 0
+      const editedRadius = '1'
+      await editFillet(firstFilletFeatureTreeIndex, '5', editedRadius)
+      await editor.expectEditor.toContain(
+        firstFilletDeclaration.replace('radius = 5', 'radius = ' + editedRadius)
+      )
+
+      // Edit back to original radius
+      await editFillet(firstFilletFeatureTreeIndex, editedRadius, '5')
+      await editor.expectEditor.toContain(firstFilletDeclaration)
+    })
+
    // Test 2: Command bar flow without preselected edges
    await test.step(`Open fillet UI without selecting edges`, async () => {
      await page.waitForTimeout(100)
@ -1944,6 +1992,23 @@ extrude001 = extrude(sketch001, length = -12)
      )
    })

+    // Test 2.1: Edit fillet (edgeSweep type)
+    await test.step('Edit fillet via feature tree selection works', async () => {
+      const secondFilletFeatureTreeIndex = 1
+      const editedRadius = '2'
+      await editFillet(secondFilletFeatureTreeIndex, '5', editedRadius)
+      await editor.expectEditor.toContain(
+        secondFilletDeclaration.replace(
+          'radius = 5',
+          'radius = ' + editedRadius
+        )
+      )
+
+      // Edit back to original radius
+      await editFillet(secondFilletFeatureTreeIndex, editedRadius, '5')
+      await editor.expectEditor.toContain(secondFilletDeclaration)
+    })
+
    // Test 3: Delete fillets
    await test.step('Delete fillet via feature tree selection', async () => {
      await test.step('Open Feature Tree Pane', async () => {
@ -1966,6 +2031,43 @@ extrude001 = extrude(sketch001, length = -12)
    })
  })

+  test(`Fillet point-and-click edit rejected when not in pipe`, async ({
+    context,
+    page,
+    homePage,
+    scene,
+    toolbar,
+  }) => {
+    const initialCode = `sketch001 = startSketchOn(XY)
+profile001 = circle(
+  sketch001,
+  center = [0, 0],
+  radius = 100,
+  tag = $seg01,
+)
+extrude001 = extrude(profile001, length = 100)
+fillet001 = fillet(extrude001, radius = 5, tags = [getOppositeEdge(seg01)])
+`
+    await context.addInitScript((initialCode) => {
+      localStorage.setItem('persistCode', initialCode)
+    }, initialCode)
+    await page.setBodyDimensions({ width: 1000, height: 500 })
+    await homePage.goToModelingScene()
+    await scene.waitForExecutionDone()
+
+    await test.step('Double-click in feature tree and expect error toast', async () => {
+      await toolbar.openPane('feature-tree')
+      const operationButton = await toolbar.getFeatureTreeOperation('Fillet', 0)
+      await operationButton.dblclick({ button: 'left' })
+      await expect(
+        page.getByText(
+          'Only chamfer and fillet in pipe expressions are supported for edits'
+        )
+      ).toBeVisible()
+      await page.waitForTimeout(1000)
+    })
+  })
+
  test(`Fillet point-and-click delete`, async ({
    context,
    page,
@ -2262,7 +2364,7 @@ extrude001 = extrude(sketch001, length = -12)
    const chamferColor: [number, number, number] = [168, 168, 168]
    const backgroundColor: [number, number, number] = [30, 30, 30]
    const lowTolerance = 20
-    const highTolerance = 40
+    const highTolerance = 70 // TODO: understand why I needed that for edgeColorYellow on macos (local)

    // Setup
    await test.step(`Initial test setup`, async () => {
@ -2344,6 +2446,57 @@ extrude001 = extrude(sketch001, length = -12)
      )
    })

+    // Test 1.1: Edit sweep
+    async function editChamfer(
+      featureTreeIndex: number,
+      oldValue: string,
+      newValue: string
+    ) {
+      await toolbar.openPane('feature-tree')
+      const operationButton = await toolbar.getFeatureTreeOperation(
+        'Chamfer',
+        featureTreeIndex
+      )
+      await operationButton.dblclick({ button: 'left' })
+      await cmdBar.expectState({
+        commandName: 'Chamfer',
+        currentArgKey: 'length',
+        currentArgValue: oldValue,
+        headerArguments: {
+          Length: oldValue,
+        },
+        highlightedHeaderArg: 'length',
+        stage: 'arguments',
+      })
+      await page.keyboard.insertText(newValue)
+      await cmdBar.progressCmdBar()
+      await cmdBar.expectState({
+        stage: 'review',
+        headerArguments: {
+          Length: newValue,
+        },
+        commandName: 'Chamfer',
+      })
+      await cmdBar.progressCmdBar()
+      await toolbar.closePane('feature-tree')
+    }
+
+    await test.step('Edit chamfer via feature tree selection works', async () => {
+      const firstChamferFeatureTreeIndex = 0
+      const editedLength = '1'
+      await editChamfer(firstChamferFeatureTreeIndex, '5', editedLength)
+      await editor.expectEditor.toContain(
+        firstChamferDeclaration.replace(
+          'length = 5',
+          'length = ' + editedLength
+        )
+      )
+
+      // Edit back to original radius
+      await editChamfer(firstChamferFeatureTreeIndex, editedLength, '5')
+      await editor.expectEditor.toContain(firstChamferDeclaration)
+    })
+
    // Test 2: Command bar flow without preselected edges
    await test.step(`Open chamfer UI without selecting edges`, async () => {
      await page.waitForTimeout(100)
@ -2428,6 +2581,23 @@ extrude001 = extrude(sketch001, length = -12)
      )
    })

+    // Test 2.1: Edit chamfer (edgeSweep type)
+    await test.step('Edit chamfer via feature tree selection works', async () => {
+      const secondChamferFeatureTreeIndex = 1
+      const editedLength = '2'
+      await editChamfer(secondChamferFeatureTreeIndex, '5', editedLength)
+      await editor.expectEditor.toContain(
+        secondChamferDeclaration.replace(
+          'length = 5',
+          'length = ' + editedLength
+        )
+      )
+
+      // Edit back to original length
+      await editChamfer(secondChamferFeatureTreeIndex, editedLength, '5')
+      await editor.expectEditor.toContain(secondChamferDeclaration)
+    })
+
    // Test 3: Delete chamfer via feature tree selection
    await test.step('Open Feature Tree Pane', async () => {
      await toolbar.openPane('feature-tree')
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/Client-side-scene-scale-should-match-engine-scale-Inch-scale-2-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/Client-side-scene-scale-should-match-engine-scale-Inch-scale-2-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/Draft-rectangles-should-look-right-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/Draft-rectangles-should-look-right-1-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/Zoom-to-fit-on-load---solid-2d-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/Zoom-to-fit-on-load---solid-2d-1-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/code-color-goober-code-color-goober-opening-window-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/code-color-goober-code-color-goober-opening-window-1-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable--XZ-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable--XZ-1-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable--YZ-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable--YZ-1-Google-Chrome-linux.png
--- a/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable-XY-1-Google-Chrome-linux.png
+++ b/e2e/playwright/snapshot-tests.spec.ts-snapshots/extrude-on-default-planes-should-be-stable-XY-1-Google-Chrome-linux.png
--- a/e2e/playwright/test-utils.ts
+++ b/e2e/playwright/test-utils.ts
@ -26,6 +26,7 @@ import { isArray } from 'lib/utils'
 import { reportRejection } from 'lib/trap'
 import { DeepPartial } from 'lib/types'
 import { Configuration } from 'lang/wasm'
+import { ProjectConfiguration } from '@rust/kcl-lib/bindings/ProjectConfiguration'

 const toNormalizedCode = (text: string) => {
  return text.replace(/\s+/g, '')
@ -761,7 +762,7 @@ export interface Paths {
 }

 export const doExport = async (
-  output: Models['OutputFormat_type'],
+  output: Models['OutputFormat3d_type'],
  rootDir: string,
  page: Page,
  exportFrom: 'dropdown' | 'sidebarButton' | 'commandBar' = 'dropdown'
@ -1125,3 +1126,15 @@ export function settingsToToml(settings: DeepPartial<Configuration>) {
 export function tomlToSettings(toml: string): DeepPartial<Configuration> {
  return TOML.parse(toml)
 }
+
+export function tomlToPerProjectSettings(
+  toml: string
+): DeepPartial<ProjectConfiguration> {
+  return TOML.parse(toml)
+}
+
+export function perProjectsettingsToToml(
+  settings: DeepPartial<ProjectConfiguration>
+) {
+  return TOML.stringify(settings as any)
+}
--- a/interface.d.ts
+++ b/interface.d.ts
@ -3,6 +3,18 @@ import fsSync from 'node:fs'
 import path from 'path'
 import { dialog, shell } from 'electron'
 import { MachinesListing } from 'components/MachineManagerProvider'
+import type { Channel } from 'src/menu/channels'
+import { Menu, WebContents } from 'electron'
+import { ZooLabel, ZooMenuEvents } from 'menu/roles'
+import type { MenuActionIPC } from 'menu/rules'
+import type { WebContentSendPayload } from 'menu/channels'
+
+// Extend the interface with additional custom properties
+declare module 'electron' {
+  interface Menu {
+    label?: ZooLabel
+  }
+}

 type EnvFn = (value?: string) => string

@ -94,6 +106,14 @@ export interface IElectronAPI {
  appCheckForUpdates: () => Promise<unknown>
  getArgvParsed: () => any
  getAppTestProperty: (propertyName: string) => any
+
+  // Helper functions to create application Menus
+  createHomePageMenu: () => Promise<any>
+  createModelingPageMenu: () => Promise<any>
+  createFallbackMenu: () => Promise<any>
+  enableMenu(menuId: string): Promise<any>
+  disableMenu(menuId: string): Promise<any>
+  menuOn: (callback: (payload: WebContentSendPayload) => void) => any
 }

 declare global {
--- a/package.json
+++ b/package.json
@ -26,7 +26,7 @@
    "@fortawesome/react-fontawesome": "^0.2.0",
    "@headlessui/react": "^1.7.19",
    "@headlessui/tailwindcss": "^0.2.0",
-    "@kittycad/lib": "2.0.17",
+    "@kittycad/lib": "2.0.21",
    "@lezer/highlight": "^1.2.1",
    "@lezer/lr": "^1.4.1",
    "@react-hook/resize-observer": "^2.0.1",
--- a/public/kcl-samples/80-20-rail/main.kcl
+++ b/public/kcl-samples/80-20-rail/main.kcl
@ -7,7 +7,7 @@
 // Define function
 fn rail8020(originStart, railHeight, railLength) {
  // Sketch side 1 of profile
-  sketch001 = startSketchOn('-XZ')
+  sketch001 = startSketchOn(-XZ)
    |> startProfileAt([
         originStart[0],
         0.1 * railHeight + originStart[1]
@ -194,7 +194,7 @@ fn rail8020(originStart, railHeight, railLength) {
           .5 * railHeight + originStart[0],
           .5 * railHeight + originStart[1]
         ],
-         radius = .205 * railHeight / 2
+         radius = .205 * railHeight / 2,
       ), %)
    |> extrude(length = railLength)
    |> fillet(
@ -216,7 +216,7 @@ fn rail8020(originStart, railHeight, railLength) {
           getNextAdjacentEdge(edge28),
           getNextAdjacentEdge(edge29),
           getNextAdjacentEdge(edge30)
-         ]
+         ],
       )
    |> fillet(
         radius = 0.03,
@ -237,7 +237,7 @@ fn rail8020(originStart, railHeight, railLength) {
           getNextAdjacentEdge(edge26),
           getNextAdjacentEdge(edge31),
           getNextAdjacentEdge(edge32)
-         ]
+         ],
       )
  return sketch001
 }
--- a/public/kcl-samples/a-parametric-bearing-pillow-block/main.kcl
+++ b/public/kcl-samples/a-parametric-bearing-pillow-block/main.kcl
@ -15,57 +15,37 @@ padding = 1.5
 bearingDia = 3

 // (Needs to be updated). Sketch the block and extrude up to where the counterbore diameter starts.
-extrude001 = startSketchOn('XY')
+extrude001 = startSketchOn(XY)
  |> startProfileAt([-width / 2, -length / 2], %)
  |> line(endAbsolute = [width / 2, -length / 2])
  |> line(endAbsolute = [width / 2, length / 2])
  |> line(endAbsolute = [-width / 2, length / 2])
  |> close()
  |> extrude(length = height)
-  
 extrude002 = startSketchOn(extrude001, 'end')
  |> circle(
-      center = [
+       center = [
         -(width / 2 - (padding / 2)),
         -(length / 2 - (padding / 2))
-      ],
-      radius = cbDia / 2,
+       ],
+       radius = cbDia / 2,
     )
-  |> patternLinear2d(
-      instances = 2,
-      distance = length - padding,
-      axis = [0, 1],
-     )
-  |> patternLinear2d(
-      instances = 2,
-      distance = width - padding,
-      axis = [1, 0],
-    )
+  |> patternLinear2d(instances = 2, distance = length - padding, axis = [0, 1])
+  |> patternLinear2d(instances = 2, distance = width - padding, axis = [1, 0])
  |> extrude(%, length = -cbDepth)

 extrude003 = startSketchOn(extrude001, 'start')
  |> circle(
-        center = [
-           -(width / 2 - (padding / 2)),
-           -(length / 2 - (padding / 2))
-        ],
-        radius = holeDia / 2,
+       center = [
+         -(width / 2 - (padding / 2)),
+         -(length / 2 - (padding / 2))
+       ],
+       radius = holeDia / 2,
     )
-  |> patternLinear2d(
-      instances = 2,
-      distance = length - padding,
-      axis = [0, 1],
-    )
-  |> patternLinear2d(
-      instances = 2,
-      distance = width - padding,
-      axis = [1, 0],
-    )
+  |> patternLinear2d(instances = 2, distance = length - padding, axis = [0, 1])
+  |> patternLinear2d(instances = 2, distance = width - padding, axis = [1, 0])
  |> extrude(length = -height + cbDepth)

 extrude004 = startSketchOn(extrude001, 'end')
-  |> circle(
-      center = [0, 0],
-      radius = bearingDia/2,
-    )
-  |> extrude(length = -height)
+  |> circle(center = [0, 0], radius = bearingDia / 2)
+  |> extrude(length = -height)
--- a/public/kcl-samples/ball-bearing/main.kcl
+++ b/public/kcl-samples/ball-bearing/main.kcl
@ -17,21 +17,15 @@ chainThickness = sphereDia / 8
 linkDiameter = sphereDia / 4

 // Sketch the inside bearing piece
-insideWallSketch = startSketchOn(offsetPlane("XY", offset = -overallThickness / 2))
-  |> circle(
-       center = [0, 0],
-       radius = shaftDia / 2 + wallThickness
-     )
-  |> hole(circle(
-       center = [0, 0],
-       radius = shaftDia / 2
-     ), %)
+insideWallSketch = startSketchOn(offsetPlane(XY, offset = -overallThickness / 2))
+  |> circle(center = [0, 0], radius = shaftDia / 2 + wallThickness)
+  |> hole(circle(center = [0, 0], radius = shaftDia / 2), %)

 // Extrude the inside bearing piece
 insideWall = extrude(insideWallSketch, length = overallThickness)

 // Create the sketch of one of the balls
-ballsSketch = startSketchOn("XY")
+ballsSketch = startSketchOn(XY)
  |> startProfileAt([shaftDia / 2 + wallThickness, 0.001], %)
  |> arc({
       angleEnd = 0,
@ -47,11 +41,11 @@ balls = revolve(ballsSketch, axis = "X")
       axis = [0, 0, 1],
       center = [0, 0, 0],
       instances = nBalls,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Create the sketch for the chain around the balls
-chainSketch = startSketchOn("XY")
+chainSketch = startSketchOn(XY)
  |> startProfileAt([
       shaftDia / 2 + wallThickness + sphereDia / 2 - (chainWidth / 2),
       0.125 * sin(toRadians(60))
@ -72,17 +66,17 @@ chainHead = revolve(chainSketch, axis = "X")
       axis = [0, 0, 1],
       center = [0, 0, 0],
       instances = nBalls,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Create the sketch for the links in between the chains
-linkSketch = startSketchOn("XZ")
+linkSketch = startSketchOn(XZ)
  |> circle(
       center = [
         shaftDia / 2 + wallThickness + sphereDia / 2,
         0
       ],
-       radius = linkDiameter / 2
+       radius = linkDiameter / 2,
     )

 // Revolve the link sketch
@ -92,19 +86,13 @@ linkRevolve = revolve(linkSketch, axis = 'Y', angle = 360 / nBalls)
       axis = [0, 0, 1],
       center = [0, 0, 0],
       instances = nBalls,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Create the sketch for the outside walls
-outsideWallSketch = startSketchOn(offsetPlane("XY", offset = -overallThickness / 2))
-  |> circle(
-       center = [0, 0],
-       radius = outsideDiameter / 2
-     )
-  |> hole(circle(
-       center = [0, 0],
-       radius = shaftDia / 2 + wallThickness + sphereDia
-     ), %)
+outsideWallSketch = startSketchOn(offsetPlane(XY, offset = -overallThickness / 2))
+  |> circle(center = [0, 0], radius = outsideDiameter / 2)
+  |> hole(circle(center = [0, 0], radius = shaftDia / 2 + wallThickness + sphereDia), %)

 outsideWall = extrude(outsideWallSketch, length = overallThickness)

--- a/public/kcl-samples/bench/bench-parts.kcl
+++ b/public/kcl-samples/bench/bench-parts.kcl
@ -130,7 +130,7 @@ fn armRestProfile(plane, offset) {

 export fn armRest(plane, offset) {
  path = armRestPath(  offsetPlane(plane, offset = offset))
-  profile = armRestProfile(  offsetPlane("-XZ", offset = 20), offset)
+  profile = armRestProfile(  offsetPlane(-XZ, offset = 20), offset)
  sweep(profile, path = path)
  return 0
 }
--- a/public/kcl-samples/bench/main.kcl
+++ b/public/kcl-samples/bench/main.kcl
@ -16,19 +16,19 @@ import backSlats from "bench-parts.kcl"
 import armRest from "bench-parts.kcl"

 // Create the dividers, these hold the seat and back slats
-divider("YZ")
-divider(offsetPlane("-YZ", offset = benchLength / 2))
-divider(offsetPlane("YZ", offset = benchLength / 2))
+divider(YZ)
+divider(offsetPlane(-YZ, offset = benchLength / 2))
+divider(offsetPlane(YZ, offset = benchLength / 2))

 // Create the connectors to join the dividers
-connector(offsetPlane("YZ", offset = -benchLength / 2), benchLength)
+connector(offsetPlane(YZ, offset = -benchLength / 2), benchLength)

 // Create the seat slats
-seatSlats(offsetPlane("YZ", offset = -benchLength / 2 - dividerThickness / 2), benchLength + dividerThickness)
+seatSlats(offsetPlane(YZ, offset = -benchLength / 2 - (dividerThickness / 2)), benchLength + dividerThickness)

 // Create the back slats
-backSlats(offsetPlane("YZ", offset = -benchLength / 2 - dividerThickness / 2), benchLength + dividerThickness)
+backSlats(offsetPlane(YZ, offset = -benchLength / 2 - (dividerThickness / 2)), benchLength + dividerThickness)

 // Create the arm rests
-armRest("-YZ", benchLength / 2)
-armRest("-YZ", -benchLength / 2)
+armRest(-YZ, benchLength / 2)
+armRest(-YZ, -benchLength / 2)
--- a/public/kcl-samples/bracket/main.kcl
+++ b/public/kcl-samples/bracket/main.kcl
@ -1,7 +1,6 @@
 // Shelf Bracket
 // 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.

-
 // Define constants
 sigmaAllow = 35000 // psi (6061-T6 aluminum)
 width = 6 // inch
@ -12,14 +11,16 @@ wallMountL = 2 // inches
 shelfDepth = 12 // Shelf is 12 inches in depth from the wall
 moment = shelfDepth * p // assume the force is applied at the end of the shelf to be conservative (lb-in)

+
 // Calculate required thickness of bracket
 thickness = sqrt(moment * factorOfSafety * 6 / (sigmaAllow * width)) // this is the calculation of two brackets holding up the shelf (inches)

+
 filletRadius = .25
 extFilletRadius = filletRadius + thickness
 mountingHoleDiameter = 0.5

-sketch001 = startSketchOn('XZ')
+sketch001 = startSketchOn(XZ)
  |> startProfileAt([0, 0], %)
  |> xLine(length = shelfMountL - thickness, tag = $seg01)
  |> yLine(length = thickness, tag = $seg02)
@ -29,48 +30,18 @@ sketch001 = startSketchOn('XZ')
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg06)
  |> close()
  |> extrude(%, length = width)
-  |> fillet(
-       radius = extFilletRadius,
-       tags = [getNextAdjacentEdge(seg03)],
-     )
-  |> fillet(
-       radius = filletRadius,
-       tags = [getNextAdjacentEdge(seg06)],
-     )
-  |> fillet(
-      radius = filletRadius,
-      tags = [seg02, getOppositeEdge(seg02)],
-    )
-  |> fillet(
-      radius = filletRadius,
-      tags = [seg05, getOppositeEdge(seg05)],
-    )
+  |> fillet(radius = extFilletRadius, tags = [getNextAdjacentEdge(seg03)])
+  |> fillet(radius = filletRadius, tags = [getNextAdjacentEdge(seg06)])
+  |> fillet(radius = filletRadius, tags = [seg02, getOppositeEdge(seg02)])
+  |> fillet(radius = filletRadius, tags = [seg05, getOppositeEdge(seg05)])

 sketch002 = startSketchOn(sketch001, seg03)
-  |> circle(
-    center = [-1.25, 1],
-    radius = mountingHoleDiameter / 2,
-  )
-  |> patternLinear2d(
-    instances = 2,
-    distance = 2.5,
-    axis = [-1, 0],
-  )
-  |> patternLinear2d(
-    instances = 2,
-    distance = 4,
-    axis = [0, 1],
-  )
-  |> extrude(%, length = -thickness-.01)
+  |> circle(center = [-1.25, 1], radius = mountingHoleDiameter / 2)
+  |> patternLinear2d(instances = 2, distance = 2.5, axis = [-1, 0])
+  |> patternLinear2d(instances = 2, distance = 4, axis = [0, 1])
+  |> extrude(%, length = -thickness - .01)

 sketch003 = startSketchOn(sketch001, seg04)
-  |> circle(
-    center = [1, -1],
-    radius = mountingHoleDiameter / 2,
-  )
-  |> patternLinear2d(
-    instances = 2,
-    distance = 4,
-    axis = [1, 0],
-  )
-  |> extrude(%, length = -thickness-0.1)
+  |> circle(center = [1, -1], radius = mountingHoleDiameter / 2)
+  |> patternLinear2d(instances = 2, distance = 4, axis = [1, 0])
+  |> extrude(%, length = -thickness - 0.1)
--- a/public/kcl-samples/car-wheel-assembly/brake-caliper.kcl
+++ b/public/kcl-samples/car-wheel-assembly/brake-caliper.kcl
@ -1,16 +1,14 @@
 // Brake Caliper
 // 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.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import caliperTolerance, caliperPadLength, caliperThickness, caliperOuterEdgeRadius, caliperInnerEdgeRadius, rotorDiameter, rotorTotalThickness, yAxisOffset from "globals.kcl"

 // Sketch the brake caliper profile
-brakeCaliperSketch = startSketchOn('XY')
+brakeCaliperSketch = startSketchOn(XY)
  |> startProfileAt([
       rotorDiameter / 2 + caliperTolerance,
       0
--- a/public/kcl-samples/car-wheel-assembly/car-rotor.kcl
+++ b/public/kcl-samples/car-wheel-assembly/car-rotor.kcl
@ -1,39 +1,28 @@
 // Wheel rotor
 // 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.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import rotorDiameter, rotorInnerDiameter, rotorSinglePlateThickness, rotorInnerDiameterThickness, lugHolePatternDia, lugSpacing, rotorTotalThickness, spacerPatternDiameter, spacerDiameter, spacerLength, spacerCount, wheelDiameter, lugCount, yAxisOffset, drillAndSlotCount from "globals.kcl"

-rotorSketch = startSketchOn('XZ')
-  |> circle(
-       center = [0, 0],
-       radius = rotorDiameter / 2
-     )
+rotorSketch = startSketchOn(XZ)
+  |> circle(center = [0, 0], radius = rotorDiameter / 2)
 rotor = extrude(rotorSketch, length = rotorSinglePlateThickness)
  |> appearance(color = "#dbcd70", roughness = 90, metalness = 90)

 rotorBumpSketch = startSketchOn(rotor, 'end')
-  |> circle(
-       center = [0, 0],
-       radius = rotorInnerDiameter / 2
-     )
+  |> circle(center = [0, 0], radius = rotorInnerDiameter / 2)
 rotorBump = extrude(rotorBumpSketch, length = rotorInnerDiameterThickness)

 lugHoles = startSketchOn(rotorBump, 'end')
-  |> circle(
-       center = [-lugSpacing / 2, 0],
-       radius = 0.315
-     )
+  |> circle(center = [-lugSpacing / 2, 0], radius = 0.315)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = lugCount,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(%, length = -(rotorInnerDiameterThickness + rotorSinglePlateThickness))
  |> appearance(color = "#dbcd70", roughness = 90, metalness = 90)
@ -44,35 +33,26 @@ centerSpacer = startSketchOn(rotor, 'start')
  |> extrude(%, length = spacerLength)

 secondaryRotorSketch = startSketchOn(centerSpacer, 'end')
-  |> circle(
-       center = [0, 0],
-       radius = rotorDiameter / 2
-     )
+  |> circle(center = [0, 0], radius = rotorDiameter / 2)
 secondRotor = extrude(secondaryRotorSketch, length = rotorSinglePlateThickness)

 lugHoles2 = startSketchOn(secondRotor, 'end')
-  |> circle(
-       center = [-lugSpacing / 2, 0],
-       radius = 0.315
-     )
+  |> circle(center = [-lugSpacing / 2, 0], radius = 0.315)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = lugCount,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(length = -rotorSinglePlateThickness)

 spacerSketch = startSketchOn(rotor, 'start')
-  |> circle(
-       center = [spacerPatternDiameter / 2, 0],
-       radius = spacerDiameter
-     )
+  |> circle(center = [spacerPatternDiameter / 2, 0], radius = spacerDiameter)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = spacerCount,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
 spacers = extrude(spacerSketch, length = spacerLength)

@ -87,7 +67,7 @@ rotorSlottedSketch = startSketchOn(rotor, 'START')
       center = [0, 0],
       instances = drillAndSlotCount,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
 rotorSlotted = extrude(rotorSlottedSketch, length = -rotorSinglePlateThickness / 2)

@ -102,7 +82,7 @@ secondRotorSlottedSketch = startSketchOn(secondRotor, 'END')
       center = [0, 0],
       instances = drillAndSlotCount,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude(secondRotorSlottedSketch, length = -rotorSinglePlateThickness / 2)
--- a/public/kcl-samples/car-wheel-assembly/car-tire.kcl
+++ b/public/kcl-samples/car-wheel-assembly/car-tire.kcl
@ -1,21 +1,22 @@
 // Tire
 // 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.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import tireInnerDiameter, tireOuterDiameter, tireDepth, bendRadius, tireTreadWidth, tireTreadDepth, tireTreadOffset from "globals.kcl"

 // Create the sketch of the tire
-tireSketch = startSketchOn("XY")
+tireSketch = startSketchOn(XY)
  |> startProfileAt([tireInnerDiameter / 2, tireDepth / 2], %)
-  |> line(endAbsolute = [
-       tireOuterDiameter / 2 - bendRadius,
-       tireDepth / 2
-     ], tag = $edge1)
+  |> line(
+       endAbsolute = [
+         tireOuterDiameter / 2 - bendRadius,
+         tireDepth / 2
+       ],
+       tag = $edge1,
+     )
  |> tangentialArc({ offset = -90, radius = bendRadius }, %)
  |> line(endAbsolute = [
       tireOuterDiameter / 2,
--- a/public/kcl-samples/car-wheel-assembly/car-wheel.kcl
+++ b/public/kcl-samples/car-wheel-assembly/car-wheel.kcl
@ -1,69 +1,49 @@
 // Car Wheel
 // A sports car wheel with a circular lug pattern and spokes.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import lugCount, lugSpacing, offset, backSpacing, wheelWidth, wheelDiameter, spokeCount, spokeGap, spokeAngle, spokeThickness from "globals.kcl"

 // Create the wheel center
-lugBase = startSketchOn('XZ')
-  |> circle(
-       center = [0, 0],
-       radius = (lugSpacing + 1.5) / 2
-     )
-  |> hole(circle(
-       center = [0, 0],
-       radius = (lugSpacing - 1.5) / 2
-     ), %)
+lugBase = startSketchOn(XZ)
+  |> circle(center = [0, 0], radius = (lugSpacing + 1.5) / 2)
+  |> hole(circle(center = [0, 0], radius = (lugSpacing - 1.5) / 2), %)
  |> extrude(length = wheelWidth / 20)

 // Extend the wheel center and bore holes to accomidate the lug heads
 lugExtrusion = startSketchOn(lugBase, 'END')
-  |> circle(
-       center = [0, 0],
-       radius = (lugSpacing + 1.5) / 2
-     )
-  |> hole(circle(
-       center = [0, 0],
-       radius = (lugSpacing - 1.5) / 2
-     ), %)
+  |> circle(center = [0, 0], radius = (lugSpacing + 1.5) / 2)
+  |> hole(circle(center = [0, 0], radius = (lugSpacing - 1.5) / 2), %)
  |> extrude(length = wheelWidth / 10)

 // Create the circular pattern for the lugs
 lugClearance = startSketchOn(lugExtrusion, 'END')
-  |> circle(
-       center = [lugSpacing / 2, 0],
-       radius = 1.2 / 2
-     )
+  |> circle(center = [lugSpacing / 2, 0], radius = 1.2 / 2)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = lugCount,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(length = -wheelWidth / 10)

 // Create the circular pattern for the lug holes
 lugHoles = startSketchOn(lugBase, 'END')
-  |> circle(
-       center = [lugSpacing / 2, 0],
-       radius = 16 * mm() / 2
-     )
+  |> circle(center = [lugSpacing / 2, 0], radius = 16 * mm() / 2)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = lugCount,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(length = -wheelWidth / 20)
  |> appearance(color = "#ffffff", metalness = 0, roughness = 0)

 // Add detail to the wheel center by revolving curved edge profiles
-wheelCenterInner = startSketchOn('XY')
+wheelCenterInner = startSketchOn(XY)
  |> startProfileAt([(lugSpacing - 1.5) / 2, 0], %)
  |> yLine(length = -wheelWidth / 10 - (wheelWidth / 20))
  |> bezierCurve({
@ -77,7 +57,7 @@ wheelCenterInner = startSketchOn('XY')
  |> revolve(axis = 'y')
  |> appearance(color = "#ffffff", metalness = 0, roughness = 0)

-wheelCenterOuter = startSketchOn('XY')
+wheelCenterOuter = startSketchOn(XY)
  |> startProfileAt([(lugSpacing + 1.5) / 2, 0], %)
  |> yLine(length = -wheelWidth / 10 - (wheelWidth / 20))
  |> bezierCurve({
@ -145,7 +125,7 @@ fn spoke(spokeGap, spokeAngle, spokeThickness) {
         center = [0, -2000, 0],
         instances = spokeCount,
         arcDegrees = 360,
-         rotateDuplicates = true
+         rotateDuplicates = true,
       )
    |> appearance(color = "#ffffff", metalness = 0, roughness = 0)
  return spokePattern
@ -155,7 +135,7 @@ spoke(spokeGap, spokeAngle, spokeThickness)
 spoke(-spokeGap, -spokeAngle, -spokeThickness)

 // Define and revolve wheel exterior
-startSketchOn('XY')
+startSketchOn(XY)
  |> startProfileAt([
       wheelDiameter / 2,
       -wheelWidth + backSpacing + offset
--- a/public/kcl-samples/car-wheel-assembly/globals.kcl
+++ b/public/kcl-samples/car-wheel-assembly/globals.kcl
@ -20,7 +20,7 @@ export lugDiameter = 24 * mm()
 export lugHeadLength = lugDiameter * .5
 export lugThreadDiameter = lugDiameter / 2 * .85
 export lugLength = 30 * mm()
-export lugThreadDepth = lugLength - 12.7 * mm()
+export lugThreadDepth = lugLength - (12.7 * mm())

 // Car Rotor
 export rotorDiameter = 12
@ -50,4 +50,4 @@ export caliperTolerance = 0.050
 export caliperPadLength = 1.6
 export caliperThickness = 0.39
 export caliperOuterEdgeRadius = 0.39
-export caliperInnerEdgeRadius = 0.12
+export caliperInnerEdgeRadius = 0.12
--- a/public/kcl-samples/car-wheel-assembly/lug-nut.kcl
+++ b/public/kcl-samples/car-wheel-assembly/lug-nut.kcl
@ -1,11 +1,9 @@
 // Lug Nut
 // 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.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import lugDiameter, lugHeadLength, lugThreadDiameter, lugLength, lugThreadDepth, lugSpacing from "globals.kcl"

--- a/public/kcl-samples/car-wheel-assembly/main.kcl
+++ b/public/kcl-samples/car-wheel-assembly/main.kcl
@ -4,24 +4,24 @@
 // Set units
@settings(defaultLengthUnit = in)

-import 'car-wheel.kcl' as carWheel
-import 'car-rotor.kcl' as carRotor
+import "car-wheel.kcl" as carWheel
+import "car-rotor.kcl" as carRotor
 import "brake-caliper.kcl" as brakeCaliper
-import 'lug-nut.kcl' as lugNut
-import 'car-tire.kcl' as carTire
-import lugCount from 'globals.kcl'
+import "lug-nut.kcl" as lugNut
+import "car-tire.kcl" as carTire
+import lugCount from "globals.kcl"

 carRotor
  |> translate(translate = [0, 0.5, 0])
 carWheel
 lugNut
  |> patternCircular3d(
-     arcDegrees = 360,
-     axis = [0, 1, 0],
-     center = [0, 0, 0],
-     instances = lugCount,
-     rotateDuplicates = false
-   )
+       arcDegrees = 360,
+       axis = [0, 1, 0],
+       center = [0, 0, 0],
+       instances = lugCount,
+       rotateDuplicates = false,
+     )
 brakeCaliper
  |> translate(translate = [0, 0.5, 0])
 carTire
--- a/public/kcl-samples/color-cube/main.kcl
+++ b/public/kcl-samples/color-cube/main.kcl
@ -6,42 +6,42 @@

 // Globals referenced in drawRectangle
 size = 100
-halfSize = size/2
+halfSize = size / 2
 extrudeLength = 1.0
 metalConstant = 50
 roughnessConstant = 50

 // Create planes for 6 sides of a cube
-bluePlane = offsetPlane('XY', offset = halfSize)
-yellowPlane = offsetPlane('XY', offset = -halfSize)
-greenPlane = offsetPlane('XZ', offset = -halfSize)
-purplePlane = offsetPlane('-XZ', offset = -halfSize)
-redPlane = offsetPlane('YZ', offset = halfSize - extrudeLength)
-tealPlane = offsetPlane('YZ', offset = -halfSize)
+bluePlane = offsetPlane(XY, offset = halfSize)
+yellowPlane = offsetPlane(XY, offset = -halfSize)
+greenPlane = offsetPlane(XZ, offset = -halfSize)
+purplePlane = offsetPlane(-XZ, offset = -halfSize)
+redPlane = offsetPlane(YZ, offset = halfSize - extrudeLength)
+tealPlane = offsetPlane(YZ, offset = -halfSize)

 // Sketch a rectangle centered at the origin of the profile
-fn sketchRectangle (profile, color) {
+fn sketchRectangle(profile, color) {
  return profile
-  |> startProfileAt([-halfSize, halfSize], %)
-  |> angledLine([0, size], %, $rectangleSegmentA001)
-  |> angledLine([
-       segAng(rectangleSegmentA001) - 90,
-       size
-     ], %, $rectangleSegmentB001)
-  |> angledLine([
-       segAng(rectangleSegmentA001),
-       -segLen(rectangleSegmentA001)
-     ], %, $rectangleSegmentC001)
-  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
-  |> close()
-  |> extrude(%, length = extrudeLength)
-  |> appearance(color = color, metalness = metalConstant, roughness = roughnessConstant)
+    |> startProfileAt([-halfSize, halfSize], %)
+    |> angledLine([0, size], %, $rectangleSegmentA001)
+    |> angledLine([
+         segAng(rectangleSegmentA001) - 90,
+         size
+       ], %, $rectangleSegmentB001)
+    |> angledLine([
+         segAng(rectangleSegmentA001),
+         -segLen(rectangleSegmentA001)
+       ], %, $rectangleSegmentC001)
+    |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
+    |> close()
+    |> extrude(%, length = extrudeLength)
+    |> appearance(color = color, metalness = metalConstant, roughness = roughnessConstant)
 }

 // Sketch each side of the cube
-sketchRectangle(bluePlane,'#0000FF')
-sketchRectangle(yellowPlane,'#FFFF00')
-sketchRectangle(greenPlane,'#00FF00')
-sketchRectangle(redPlane,'#FF0000')
-sketchRectangle(tealPlane,'#00FFFF')
-sketchRectangle(purplePlane,'#FF00FF')
+sketchRectangle(bluePlane, '#0000FF')
+sketchRectangle(yellowPlane, '#FFFF00')
+sketchRectangle(greenPlane, '#00FF00')
+sketchRectangle(redPlane, '#FF0000')
+sketchRectangle(tealPlane, '#00FFFF')
+sketchRectangle(purplePlane, '#FF00FF')
--- a/public/kcl-samples/cycloidal-gear/main.kcl
+++ b/public/kcl-samples/cycloidal-gear/main.kcl
@ -4,12 +4,11 @@
 // Set Units
@settings(defaultLengthUnit = in)

-
 fn cycloidalGear(gearPitch, gearHeight, holeDiameter, helixAngle) {
  // Create a function to draw the gear profile as a sketch. Rotate each profile about the gear's axis by an helix angle proportional to the total gear height
  fn gearSketch(gHeight) {
    helixAngleP = helixAngle * gHeight / gearHeight
-    gearProfile = startSketchOn(offsetPlane("XY", offset = gHeight))
+    gearProfile = startSketchOn(offsetPlane(XY, offset = gHeight))
      |> startProfileAt([
           gearPitch * 1.55 * cos(toRadians(helixAngleP)) + gearPitch * sin(toRadians(-helixAngleP)),
           gearPitch * 1.55 * sin(toRadians(helixAngleP)) + gearPitch * cos(toRadians(-helixAngleP))
@ -31,10 +30,7 @@ fn cycloidalGear(gearPitch, gearHeight, holeDiameter, helixAngle) {
      |> tangentialArc({ radius = gearPitch, offset = -180 }, %)
      |> tangentialArcTo([profileStartX(%), profileStartY(%)], %)
      |> close(%)
-      |> hole(circle(
-           center = [0, 0],
-           radius = holeDiameter / 2
-         ), %)
+      |> hole(circle(center = [0, 0], radius = holeDiameter / 2), %)
    return gearProfile
  }

--- a/public/kcl-samples/dodecahedron/main.kcl
+++ b/public/kcl-samples/dodecahedron/main.kcl
@ -39,7 +39,7 @@ plane = {
 }

 // Create a regular pentagon inscribed in a circle of radius pentR
-bottomFace = startSketchOn('XY')
+bottomFace = startSketchOn(XY)
  |> polygon({
       radius = pentR,
       numSides = 5,
@ -66,7 +66,7 @@ bottomBowl = patternCircular3d(
  axis = [0, 0, 1],
  center = [0, 0, 0],
  arcDegrees = 360,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // pattern the bottom to create the top face
@ -76,7 +76,7 @@ patternCircular3d(
  axis = [0, 1, 0],
  center = [0, 0, inscR],
  arcDegrees = 360,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // pattern the bottom angled faces to create the top
@ -86,5 +86,5 @@ patternCircular3d(
  axis = [0, 1, 0],
  center = [0, 0, inscR],
  arcDegrees = 360,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )
--- a/public/kcl-samples/enclosure/main.kcl
+++ b/public/kcl-samples/enclosure/main.kcl
@ -11,7 +11,7 @@ wallThickness = 3
 holeDia = 4

 // Model a box with base enclosure dimensions
-sketch001 = startSketchOn('XY')
+sketch001 = startSketchOn(XY)
  |> startProfileAt([0, 0], %)
  |> angledLine([0, width], %, $rectangleSegmentA001)
  |> angledLine([
@ -32,14 +32,11 @@ extrude001 = extrude(sketch001, length = height)
         getNextAdjacentEdge(rectangleSegmentB001),
         getNextAdjacentEdge(rectangleSegmentC001),
         getNextAdjacentEdge(rectangleSegmentD001)
-       ]
+       ],
     )

  // Apply a shell to the enclosure base to create the internal storage
-  |> shell(
-       faces = ["end"],
-       thickness = wallThickness
-     )
+  |> shell(faces = ["end"], thickness = wallThickness)

 // Define a function to create the internal structure to secure a fastener at each corner
 fn function001(originStart) {
@ -55,14 +52,8 @@ fn function001(originStart) {

  // Create a pillar with a fasterner hole at the center
  sketch002 = startSketchOn(plane001)
-    |> circle(
-         center = [originStart[0], originStart[1]],
-         radius = holeDia + wallThickness
-       )
-    |> hole(circle(
-         center = [originStart[0], originStart[1]],
-         radius = holeDia
-       ), %)
+    |> circle(center = [originStart[0], originStart[1]], radius = holeDia + wallThickness)
+    |> hole(circle(center = [originStart[0], originStart[1]], radius = holeDia), %)
  extrude002 = extrude(sketch002, length = height - wallThickness)

  return extrude002
@ -87,7 +78,7 @@ function001([
 ])

 // Define lid position and outer surface
-sketch003 = startSketchOn('XY')
+sketch003 = startSketchOn(XY)
  |> startProfileAt([width * 1.2, 0], %)
  |> angledLine([0, width], %, $rectangleSegmentA002)
  |> angledLine([
@ -105,28 +96,28 @@ sketch003 = startSketchOn('XY')
         width * 1.2 + wallThickness * 3 + holeDia,
         wallThickness * 3 + holeDia
       ],
-       radius = holeDia
+       radius = holeDia,
     ), %)
  |> hole(circle(
       center = [
         width * 1.2 + wallThickness * 3 + holeDia,
         length - (wallThickness * 3 + holeDia)
       ],
-       radius = holeDia
+       radius = holeDia,
     ), %)
  |> hole(circle(
       center = [
         width * 2.2 - (wallThickness * 3 + holeDia),
         wallThickness * 3 + holeDia
       ],
-       radius = holeDia
+       radius = holeDia,
     ), %)
  |> hole(circle(
       center = [
         width * 2.2 - (wallThickness * 3 + holeDia),
         length - (wallThickness * 3 + holeDia)
       ],
-       radius = holeDia
+       radius = holeDia,
     ), %)
 extrude003 = extrude(sketch003, length = wallThickness)
  |> fillet(
@ -136,7 +127,7 @@ extrude003 = extrude(sketch003, length = wallThickness)
         getNextAdjacentEdge(rectangleSegmentB002),
         getNextAdjacentEdge(rectangleSegmentC002),
         getNextAdjacentEdge(rectangleSegmentD002)
-       ]
+       ],
     )

 // Define lid inner and sealing surfaces
@ -161,28 +152,28 @@ sketch004 = startSketchOn(extrude003, 'END')
         width * 1.2 + wallThickness * 3 + holeDia,
         wallThickness * 3 + holeDia
       ],
-       radius = holeDia + wallThickness
+       radius = holeDia + wallThickness,
     ), %)
  |> hole(circle(
       center = [
         width * 1.2 + wallThickness * 3 + holeDia,
         length - (wallThickness * 3 + holeDia)
       ],
-       radius = holeDia + wallThickness
+       radius = holeDia + wallThickness,
     ), %)
  |> hole(circle(
       center = [
         width * 2.2 - (wallThickness * 3 + holeDia),
         wallThickness * 3 + holeDia
       ],
-       radius = holeDia + wallThickness
+       radius = holeDia + wallThickness,
     ), %)
  |> hole(circle(
       center = [
         width * 2.2 - (wallThickness * 3 + holeDia),
         length - (wallThickness * 3 + holeDia)
       ],
-       radius = holeDia + wallThickness
+       radius = holeDia + wallThickness,
     ), %)
 extrude004 = extrude(sketch004, length = wallThickness)
  |> fillet(
@ -192,5 +183,5 @@ extrude004 = extrude(sketch004, length = wallThickness)
         getNextAdjacentEdge(rectangleSegmentB003),
         getNextAdjacentEdge(rectangleSegmentC003),
         getNextAdjacentEdge(rectangleSegmentD003)
-       ]
+       ],
     )
--- a/public/kcl-samples/exhaust-manifold/main.kcl
+++ b/public/kcl-samples/exhaust-manifold/main.kcl
@ -45,15 +45,9 @@ fn primaryTube(n, angle001, length001, length002, length003) {
       }, %)

  // Create the cross section of each tube and sweep them
-  sweepProfile = startSketchOn('XY')
-    |> circle(
-         center = [pos001, 0],
-         radius = primaryTubeDiameter / 2
-       )
-    |> hole(circle(
-         center = [pos001, 0],
-         radius = primaryTubeDiameter / 2 - wallThickness
-       ), %)
+  sweepProfile = startSketchOn(XY)
+    |> circle(center = [pos001, 0], radius = primaryTubeDiameter / 2)
+    |> hole(circle(center = [pos001, 0], radius = primaryTubeDiameter / 2 - wallThickness), %)
    |> sweep(path = sweepPath)

  return {  }
@ -66,7 +60,7 @@ primaryTube(2, 24.3, 5, 5, 3)
 primaryTube(3, 25.2, 5, 5, 3)

 // Create the mounting flange for the header
-flangeSketch = startSketchOn('XY')
+flangeSketch = startSketchOn(XY)
  |> startProfileAt([3 + 1.3, -1.25], %)
  |> xLine(length = -2.6, tag = $seg01)
  |> tangentialArc({ radius = .3, offset = -40 }, %)
@ -87,22 +81,10 @@ flangeSketch = startSketchOn('XY')
  |> close()

  // Create openings in the flange to accommodate each tube
-  |> hole(circle(
-       center = [0, 0],
-       radius = primaryTubeDiameter / 2 - wallThickness
-     ), %)
-  |> hole(circle(
-       center = [2, 0],
-       radius = primaryTubeDiameter / 2 - wallThickness
-     ), %)
-  |> hole(circle(
-       center = [4, 0],
-       radius = primaryTubeDiameter / 2 - wallThickness
-     ), %)
-  |> hole(circle(
-       center = [6, 0],
-       radius = primaryTubeDiameter / 2 - wallThickness
-     ), %)
+  |> hole(circle(center = [0, 0], radius = primaryTubeDiameter / 2 - wallThickness), %)
+  |> hole(circle(center = [2, 0], radius = primaryTubeDiameter / 2 - wallThickness), %)
+  |> hole(circle(center = [4, 0], radius = primaryTubeDiameter / 2 - wallThickness), %)
+  |> hole(circle(center = [6, 0], radius = primaryTubeDiameter / 2 - wallThickness), %)

  // Add mounting holes to the flange
  |> hole(circle(
@ -110,28 +92,28 @@ flangeSketch = startSketchOn('XY')
         -primaryTubeDiameter * .6,
         -primaryTubeDiameter * .6
       ],
-       radius = 0.25 / 2
+       radius = 0.25 / 2,
     ), %)
  |> hole(circle(
       center = [
         primaryTubeDiameter * .6,
         primaryTubeDiameter * .6
       ],
-       radius = 0.25 / 2
+       radius = 0.25 / 2,
     ), %)
  |> hole(circle(
       center = [
         3 * 2 - (primaryTubeDiameter * .6),
         primaryTubeDiameter * .6
       ],
-       radius = 0.25 / 2
+       radius = 0.25 / 2,
     ), %)
  |> hole(circle(
       center = [
         3 * 2 + primaryTubeDiameter * .6,
         -primaryTubeDiameter * .6
       ],
-       radius = 0.25 / 2
+       radius = 0.25 / 2,
     ), %)

  // Extrude the flange and fillet the edges
@ -141,12 +123,12 @@ flangeSketch = startSketchOn('XY')
       tags = [
         getNextAdjacentEdge(seg04),
         getNextAdjacentEdge(seg07)
-       ]
+       ],
     )
  |> fillet(
       radius = .25,
       tags = [
         getNextAdjacentEdge(seg03),
         getNextAdjacentEdge(seg08)
-       ]
+       ],
     )
--- a/public/kcl-samples/flange/main.kcl
+++ b/public/kcl-samples/flange/main.kcl
@ -21,44 +21,32 @@ nHoles = 4
 assertGreaterThan(nHoles, 1, "nHoles must be greater than 1")

 // Create the circular pattern for the mounting holes
-circles = startSketchOn('XY')
-  |> circle(
-       center = [mountingHolePlacementDiameter / 2, 0],
-       radius = mountingHoleDia / 2
-     )
+circles = startSketchOn(XY)
+  |> circle(center = [mountingHolePlacementDiameter / 2, 0], radius = mountingHoleDia / 2)
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = nHoles,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Create the base of the flange and add the mounting holes
-flangeBase = startSketchOn('XY')
-  |> circle(
-       center = [0, 0],
-       radius = baseDia / 2
-     )
+flangeBase = startSketchOn(XY)
+  |> circle(center = [0, 0], radius = baseDia / 2)
  |> hole(circles, %)
  |> extrude(length = baseThickness)

 // Create the extrusion on the top of the flange base
 topExtrusion = startSketchOn(flangeBase, 'end')
-  |> circle(
-       center = [0, 0],
-       radius = topTotalDiameter / 2
-     )
+  |> circle(center = [0, 0], radius = topTotalDiameter / 2)
  |> extrude(length = topTotalThickness)

 // Create the extrusion on the bottom of the flange base
 bottomExtrusion = startSketchOn(flangeBase, 'start')
-  |> circle(
-       center = [0, 0],
-       radius = bottomTotalDiameter / 2
-     )
+  |> circle(center = [0, 0], radius = bottomTotalDiameter / 2)
  |> extrude(length = bottomThickness)

 // Cut a hole through the entire body
 pipeHole = startSketchOn(topExtrusion, 'end')
-  |> circle(center = [0, 0], radius = pipeDia/2)
+  |> circle(center = [0, 0], radius = pipeDia / 2)
  |> extrude(%, length = -(topTotalThickness + baseThickness + bottomThickness))
--- a/public/kcl-samples/focusrite-scarlett-mounting-bracket/main.kcl
+++ b/public/kcl-samples/focusrite-scarlett-mounting-bracket/main.kcl
@ -62,7 +62,7 @@ bracketBody = bs
         getPreviousAdjacentEdge(bs.tags.edge2),
         getPreviousAdjacentEdge(bs.tags.edge3),
         getPreviousAdjacentEdge(bs.tags.edge6)
-       ]
+       ],
     )

 // define the tab plane
@ -87,7 +87,7 @@ tabsR = startSketchOn(tabPlane)
         width / 2 + thk + tabWidth / 2,
         length / 2 + thk - (tabLength / (3 / 2))
       ],
-       radius = holeDiam / 2
+       radius = holeDiam / 2,
     ), %)
  |> extrude(length = -tabThk)
  |> fillet(
@ -95,13 +95,9 @@ tabsR = startSketchOn(tabPlane)
       tags = [
         getNextAdjacentEdge(edge11),
         getNextAdjacentEdge(edge12)
-       ]
-     )
-  |> patternLinear3d(
-       axis = [0, -1, 0],
-       instances = 2,
-       distance = length + 2 * thk - (tabLength * 4 / 3)
+       ],
     )
+  |> patternLinear3d(axis = [0, -1, 0], instances = 2, distance = length + 2 * thk - (tabLength * 4 / 3))

 // build the tabs of the mounting bracket (left side)
 tabsL = startSketchOn(tabPlane)
@ -115,7 +111,7 @@ tabsL = startSketchOn(tabPlane)
         -width / 2 - thk - (tabWidth / 2),
         length / 2 + thk - (tabLength / (3 / 2))
       ],
-       radius = holeDiam / 2
+       radius = holeDiam / 2,
     ), %)
  |> extrude(length = -tabThk)
  |> fillet(
@ -123,13 +119,9 @@ tabsL = startSketchOn(tabPlane)
       tags = [
         getNextAdjacentEdge(edge21),
         getNextAdjacentEdge(edge22)
-       ]
-     )
-  |> patternLinear3d(
-       axis = [0, -1, 0],
-       instances = 2,
-       distance = length + 2 * thk - (tabLength * 4 / 3)
+       ],
     )
+  |> patternLinear3d(axis = [0, -1, 0], instances = 2, distance = length + 2 * thk - (tabLength * 4 / 3))

 // define a plane for retention bumps
 retPlane = {
--- a/public/kcl-samples/food-service-spatula/main.kcl
+++ b/public/kcl-samples/food-service-spatula/main.kcl
@ -44,7 +44,7 @@ fn slot(sketch1, start, end, width) {
 }

 // create a sketch on the "XY" plane
-sketch000 = startSketchOn('XY')
+sketch000 = startSketchOn(XY)

 // create a profile of the flipper
 flipperProfile = startProfileAt([-flipperLength, -32.0], sketch000)
@ -83,11 +83,11 @@ fillet(
  tags = [
    getNextAdjacentEdge(backEdge),
    getPreviousAdjacentEdge(backEdge)
-  ]
+  ],
 )

 // create a sketch on the "XZ" plane offset by half the thickness
-sketch001 = startSketchOn(offsetPlane("XZ", offset = -handleWidth / 2))
+sketch001 = startSketchOn(offsetPlane(XZ, offset = -handleWidth / 2))

 // create a profile of the spatula handle
 handleProfile = startProfileAt([0.0, flipperThickness], sketch001)
@ -109,7 +109,7 @@ fillet(
  tags = [
    getNextAdjacentEdge(handleBottomEdge),
    getNextAdjacentEdge(handleTopEdge)
-  ]
+  ],
 )

 // define a plane which is at the end of the handle
@ -163,4 +163,4 @@ sketch003 = startSketchOn(grip, gripEdgeTop)
 gripHoleProfile = slot(sketch003, [0, 200], [0, 210], gripSlotWidth)

 // cut a hole in the grip
-extrude(gripHoleProfile, length = -gripWidth-20)
+extrude(gripHoleProfile, length = -gripWidth - 20)
--- a/public/kcl-samples/french-press/main.kcl
+++ b/public/kcl-samples/french-press/main.kcl
@ -10,7 +10,7 @@ carafeHeight = 7.32
 handleThickness = 0.65

 // Upper ring of the metal structure
-sketch001 = startSketchOn('XZ')
+sketch001 = startSketchOn(XZ)
  |> startProfileAt([carafeDiameter / 2, 5.7], %)
  |> angledLine([0, 0.1], %, $rectangleSegmentA001)
  |> angledLine([
@ -91,15 +91,12 @@ sketch002 = startSketchOn(plane001)
       center = [0, 0, 0],
       instances = 4,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Cross plate
-sketch003 = startSketchOn(offsetPlane('XY', offset = 1))
-  |> circle(
-       center = [0, 0],
-       radius = carafeDiameter / 2 - 0.15
-     )
+sketch003 = startSketchOn(offsetPlane(XY, offset = 1))
+  |> circle(center = [0, 0], radius = carafeDiameter / 2 - 0.15)

 extrude001 = extrude(sketch003, length = 0.050)

@ -117,13 +114,13 @@ sketch004 = startSketchOn(extrude001, 'END')
       center = [0, 0],
       instances = 3,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude002 = extrude(sketch004, length = -0.050)

 // Filter screen
-sketch005 = startSketchOn('XZ')
+sketch005 = startSketchOn(XZ)
  |> startProfileAt([0.15, 1.11], %)
  |> xLine(endAbsolute = carafeDiameter / 2 - 0.2)
  |> angledLineToX({
@ -138,7 +135,7 @@ sketch005 = startSketchOn('XZ')
  |> revolve(axis = 'y')

 // Plunger and stem
-sketch006 = startSketchOn('XZ')
+sketch006 = startSketchOn(XZ)
  |> startProfileAt([0.1, 1], %)
  |> line(end = [0.1, 0])
  |> angledLineToX({ angle = 10, to = 0.05 }, %)
@ -151,11 +148,8 @@ sketch006 = startSketchOn('XZ')
  |> revolve(axis = 'y')

 // Spiral plate
-sketch007 = startSketchOn(offsetPlane('XY', offset = 1.12))
-  |> circle(
-       center = [0, 0],
-       radius = carafeDiameter / 2 - 0.24
-     )
+sketch007 = startSketchOn(offsetPlane(XY, offset = 1.12))
+  |> circle(center = [0, 0], radius = carafeDiameter / 2 - 0.24)
  |> hole(circle(center = [0, 0], radius = .15), %)

 extrude003 = extrude(sketch007, length = 0.050)
@ -167,7 +161,7 @@ sketch008 = startSketchOn(extrude003, 'END')
       center = [0, 0],
       instances = 8,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude004 = extrude(sketch008, length = -0.050)
@ -179,24 +173,21 @@ sketch009 = startSketchOn(extrude003, 'END')
       center = [0, 0],
       instances = 4,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude005 = extrude(sketch009, length = -0.050)

 // Extrude a glass carafe body
-sketch010 = startSketchOn("XY")
-  |> circle(
-       center = [0, 0],
-       radius = carafeDiameter / 2
-     )
+sketch010 = startSketchOn(XY)
+  |> circle(center = [0, 0], radius = carafeDiameter / 2)

 // Perform a shell operation to hollow the carafe body with the top face removed
 extrude006 = extrude(sketch010, length = carafeHeight)
  |> shell(faces = ["end"], thickness = .07)

 // Draw and revolve the lid
-sketch011 = startSketchOn('XZ')
+sketch011 = startSketchOn(XZ)
  |> startProfileAt([0.2, carafeHeight - 0.7], %)
  |> xLine(length = carafeDiameter / 2 - 0.3)
  |> yLine(length = 0.7)
@ -213,7 +204,7 @@ sketch011 = startSketchOn('XZ')
  |> revolve(axis = 'y')

 // Draw and extrude handle
-sketch012 = startSketchOn(offsetPlane('XZ', offset = handleThickness / 2))
+sketch012 = startSketchOn(offsetPlane(XZ, offset = handleThickness / 2))
  |> startProfileAt([2.3, 6.4], %)
  |> line(end = [0.56, 0])
  |> tangentialArcTo([4.1, 5.26], %)
--- a/public/kcl-samples/gear-rack/main.kcl
+++ b/public/kcl-samples/gear-rack/main.kcl
@ -12,7 +12,7 @@ height = 12
 minHeight = 10.875

 // Create the body of the rack
-rackBody = startSketchOn('XY')
+rackBody = startSketchOn(XY)
  |> startProfileAt([-length / 2, 0], %)
  |> line(end = [length, 0])
  |> line(end = [0, minHeight])
@ -22,7 +22,7 @@ rackBody = startSketchOn('XY')

 // Create a function for sketch of a single tooth
 fn tooth() {
-  toothSketch = startSketchOn('XY')
+  toothSketch = startSketchOn(XY)
    |> startProfileAt([-length / 2 + 0.567672, minHeight], %)
    |> tangentialArcToRelative([0.157636, 0.110378], %)
    |> line(end = [0.329118, 0.904244])
@ -38,14 +38,10 @@ fn tooth() {

 // Pattern the single tooth over the length of the rack body
 teeth = tooth()
-  |> patternLinear3d(
-       axis = [10, 0, 0],
-       distance = 1.570796,
-       instances = 63
-     )
+  |> patternLinear3d(axis = [10, 0, 0], distance = 1.570796, instances = 63)

 // Sketch and extrude the first end cap. This is a partial tooth
-endCapTooth = startSketchOn('XY')
+endCapTooth = startSketchOn(XY)
  |> startProfileAt([-length / 2, 11.849525], %)
  |> line(end = [0.314524, -0.864147])
  |> tangentialArcToRelative([0.157636, -0.110378], %)
@ -54,7 +50,7 @@ endCapTooth = startSketchOn('XY')
  |> extrude(length = width)

 // Sketch and extrude the second end cap. This is a partial tooth
-endCapTooth2 = startSketchOn('XY')
+endCapTooth2 = startSketchOn(XY)
  |> startProfileAt([length / 2, 11.849525], %)
  |> line(end = [-0.314524, -0.864147])
  |> tangentialArcToRelative([-0.157636, -0.110378], %)
--- a/public/kcl-samples/gear/main.kcl
+++ b/public/kcl-samples/gear/main.kcl
@ -17,35 +17,32 @@ gearHeight = 3

 // Interpolate points along the involute curve
 cmo = 101
-rs = map([0..cmo], fn (i) {
+rs = map([0..cmo], fn(i) {
  return baseDiameter / 2 + i / cmo * (tipDiameter - baseDiameter) / 2
 })

 // Calculate operating pressure angle
-angles = map(rs, fn (r) {
+angles = map(rs, fn(r) {
  return toDegrees(  acos(baseDiameter / 2 / r))
 })

 // Calculate the involute function
-invas = map(angles, fn (a) {
+invas = map(angles, fn(a) {
  return tan(toRadians(a)) - toRadians(a)
 })

 // Map the involute curve
-xs = map([0..cmo], fn (i) {
+xs = map([0..cmo], fn(i) {
  return rs[i] * cos(invas[i])
 })

-ys = map([0..cmo], fn (i) {
+ys = map([0..cmo], fn(i) {
  return rs[i] * sin(invas[i])
 })

 // Extrude the gear body
-body = startSketchOn('XY')
-  |> circle(
-       center = [0, 0],
-       radius = baseDiameter / 2
-     )
+body = startSketchOn(XY)
+  |> circle(center = [0, 0], radius = baseDiameter / 2)
  |> extrude(length = gearHeight)

 toothAngle = 360 / nTeeth / 1.5
@ -63,7 +60,7 @@ fn rightInvolute(i, sg) {
 }

 // Draw gear teeth
-start = startSketchOn('XY')
+start = startSketchOn(XY)
  |> startProfileAt([xs[101], ys[101]], %)
 teeth = reduce([0..100], start, leftInvolute)
  |> arc({
@ -79,7 +76,7 @@ teeth = reduce([0..100], start, leftInvolute)
       center = [0, 0, 0],
       instances = nTeeth,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // Define the constants of the keyway and the bore hole
--- a/public/kcl-samples/gridfinity-baseplate-magnets/main.kcl
+++ b/public/kcl-samples/gridfinity-baseplate-magnets/main.kcl
@ -34,7 +34,7 @@ fn face(plane) {
 }

 // extrude a single side of the bin
-singleSide = extrude(face(offsetPlane("YZ", offset = cornerRadius)), length = binLength - (cornerRadius * 2), )
+singleSide = extrude(face(offsetPlane(YZ, offset = cornerRadius)), length = binLength - (cornerRadius * 2))

 // create the other sides of the bin by using a circular pattern
 sides = patternCircular3d(
@ -43,7 +43,7 @@ sides = patternCircular3d(
  axis = [0, 0, 1],
  center = [binLength / 2, binLength / 2, 0],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // define an axis axis000
@ -55,7 +55,7 @@ axis000 = {
 }

 // create a single corner of the bin
-singleCorner = revolve(face(offsetPlane("YZ", offset = cornerRadius)), angle = -90, axis = axis000)
+singleCorner = revolve(face(offsetPlane(YZ, offset = cornerRadius)), angle = -90, axis = axis000)

 // create the corners of the bin
 corners = patternCircular3d(
@ -64,7 +64,7 @@ corners = patternCircular3d(
  axis = [0, 0, 1],
  center = [binLength / 2, binLength / 2, 0],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // create the baseplate by patterning sides
@ -72,26 +72,18 @@ basePlateSides = patternLinear3d(
       sides,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)

 // create the corners of the baseplate by patterning the corners
 basePlateCorners = patternLinear3d(
       corners,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)

 // create the center cutout for the magnet profile
 fn magnetCenterCutout(plane) {
@ -149,20 +141,17 @@ fn magnetBase(plane) {
 }

 // create sketch profile sketch000Profile002
-magnetsSketch = startSketchOn('XY')
-  |> circle(
-       center = [cornerRadius * 2, cornerRadius * 2],
-       radius = magOuterDiam / 2
-     )
+magnetsSketch = startSketchOn(XY)
+  |> circle(center = [cornerRadius * 2, cornerRadius * 2], radius = magOuterDiam / 2)
  |> patternCircular2d(
       center = [binLength / 2, binLength / 2],
       instances = 4,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 // create a profile with holes for the magnets
-magnetProfile = magnetBase("XY")
+magnetProfile = magnetBase(XY)
  |> hole(magnetsSketch, %)

 // create an extrusion of the magnet cutout with holes
@ -177,11 +166,11 @@ magnetHolesExtrudeFillets = fillet(
    getPreviousAdjacentEdge(magnetHolesExtrude.sketch.tags.line001),
    getNextAdjacentEdge(magnetHolesExtrude.sketch.tags.line003),
    getPreviousAdjacentEdge(magnetHolesExtrude.sketch.tags.line003)
-  ]
+  ],
 )

 // create a profile without the holes for the magnets
-magnetProfileNoMagnets = magnetBase(offsetPlane("XY", offset = -magDepth))
+magnetProfileNoMagnets = magnetBase(offsetPlane(XY, offset = -magDepth))

 // create an extrusion of the magnet cutout without holes
 magnetCutoutExtrude = extrude(magnetProfileNoMagnets, length = -magDepth)
@ -195,7 +184,7 @@ magnetCutoutExtrudeFillets = fillet(
    getPreviousAdjacentEdge(magnetCutoutExtrude.sketch.tags.line001),
    getNextAdjacentEdge(magnetCutoutExtrude.sketch.tags.line003),
    getPreviousAdjacentEdge(magnetCutoutExtrude.sketch.tags.line003)
-  ]
+  ],
 )

 // pattern the magnet cutouts with holes
@ -203,23 +192,15 @@ patternLinear3d(
       magnetHolesExtrudeFillets,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)

 // pattern the magnet cutouts without holes
 patternLinear3d(
       magnetCutoutExtrudeFillets,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)
--- a/public/kcl-samples/gridfinity-baseplate/main.kcl
+++ b/public/kcl-samples/gridfinity-baseplate/main.kcl
@ -31,7 +31,7 @@ fn face(plane) {
 }

 // extrude a single side of the bin
-singleSide = extrude(face(offsetPlane("YZ", offset = cornerRadius)), length = binLength - (cornerRadius * 2))
+singleSide = extrude(face(offsetPlane(YZ, offset = cornerRadius)), length = binLength - (cornerRadius * 2))

 // create the other sides of the bin by using a circular pattern
 sides = patternCircular3d(
@ -40,7 +40,7 @@ sides = patternCircular3d(
  axis = [0, 0, 1],
  center = [binLength / 2, binLength / 2, 0],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // define an axis axis000
@ -52,7 +52,7 @@ axis000 = {
 }

 // create a single corner of the bin
-singleCorner = revolve(face(offsetPlane("YZ", offset = cornerRadius)), angle = -90, axis = axis000)
+singleCorner = revolve(face(offsetPlane(YZ, offset = cornerRadius)), angle = -90, axis = axis000)

 // create the corners of the bin
 corners = patternCircular3d(
@ -61,7 +61,7 @@ corners = patternCircular3d(
  axis = [0, 0, 1],
  center = [binLength / 2, binLength / 2, 0],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // create the baseplate by patterning sides
@ -69,23 +69,15 @@ basePlateSides = patternLinear3d(
       sides,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)

 // create the corners of the baseplate by patterning the corners
 basePlateCorners = patternLinear3d(
       corners,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength
+       distance = binLength,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength)
--- a/public/kcl-samples/gridfinity-bins-stacking-lip/main.kcl
+++ b/public/kcl-samples/gridfinity-bins-stacking-lip/main.kcl
@ -47,7 +47,7 @@ fn face(plane) {
 }

 // extrude a single side of the bin
-singleSide = extrude(face(offsetPlane("YZ", offset = cornerRadius + binTol)), length = binLength - (cornerRadius * 2))
+singleSide = extrude(face(offsetPlane(YZ, offset = cornerRadius + binTol)), length = binLength - (cornerRadius * 2))

 // create the other sides of the bin by using a circular pattern
 sides = patternCircular3d(
@ -60,7 +60,7 @@ sides = patternCircular3d(
    0
  ],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // define an axis axis000
@ -75,7 +75,7 @@ axis000 = {
 }

 // create a single corner of the bin
-singleCorner = revolve(face(offsetPlane("YZ", offset = cornerRadius + binTol)), angle = -90, axis = axis000)
+singleCorner = revolve(face(offsetPlane(YZ, offset = cornerRadius + binTol)), angle = -90, axis = axis000)

 // create the corners of the bin
 corners = patternCircular3d(
@ -88,10 +88,10 @@ corners = patternCircular3d(
    0
  ],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

-singleBinFill = startSketchOn("XY")
+singleBinFill = startSketchOn(XY)
  |> startProfileAt([
       binBaseLength + binTol,
       binBaseLength + binTol
@ -108,7 +108,7 @@ singleBinFill = startSketchOn("XY")
         getPreviousAdjacentEdge(line000),
         getNextAdjacentEdge(line002),
         getPreviousAdjacentEdge(line002)
-       ]
+       ],
     )

 magCutout000 = startSketchOn(singleBinFill, "start")
@ -117,7 +117,7 @@ magCutout000 = startSketchOn(singleBinFill, "start")
         -magOffset - binBaseLength - binTol,
         magOffset + binBaseLength + binTol
       ],
-       radius = magOuterDiam / 2
+       radius = magOuterDiam / 2,
     )
  |> patternCircular2d(
       arcDegrees = 360,
@ -126,7 +126,7 @@ magCutout000 = startSketchOn(singleBinFill, "start")
         (binLength + 2 * binTol) / 2
       ],
       instances = 4,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(length = -magDepth)

@ -135,42 +135,30 @@ binSides = patternLinear3d(
       sides,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 // create the corners of the baseplate by patterning the corners
 binCorners = patternLinear3d(
       corners,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 // create the fill of the bin by patterning the corners
 binFill = patternLinear3d(
       singleBinFill,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 //
-binTop = startSketchOn(offsetPlane("XY", offset = height))
+binTop = startSketchOn(offsetPlane(XY, offset = height))
  |> startProfileAt([0, 0], %)
  |> xLine(length = (binLength + 2 * binTol) * countBinWidth, tag = $line010)
  |> yLine(length = (binLength + 2 * binTol) * countBinLength, tag = $line011)
@ -184,7 +172,7 @@ binTop = startSketchOn(offsetPlane("XY", offset = height))
         getPreviousAdjacentEdge(line010),
         getNextAdjacentEdge(line012),
         getPreviousAdjacentEdge(line012)
-       ]
+       ],
     )
  |> shell(faces = ["end"], thickness = binThk)

@ -265,7 +253,7 @@ lipLengths = patternCircular3d(
    0
  ],
  instances = 2,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // create the other sides of the lips by using a circular pattern
@ -279,7 +267,7 @@ lipWidths = patternCircular3d(
    0
  ],
  instances = 2,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // define an axis axis000
@ -307,7 +295,7 @@ lipCorners000 = patternCircular3d(
    0
  ],
  instances = 2,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // create the corners of the bin
@ -321,5 +309,5 @@ lipCorners001 = patternCircular3d(
    0
  ],
  instances = 2,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )
--- a/public/kcl-samples/gridfinity-bins/main.kcl
+++ b/public/kcl-samples/gridfinity-bins/main.kcl
@ -40,7 +40,7 @@ fn face(plane) {
 }

 // extrude a single side of the bin
-singleSide = extrude(face(offsetPlane("YZ", offset = cornerRadius + binTol)), length = binLength - (cornerRadius * 2), )
+singleSide = extrude(face(offsetPlane(YZ, offset = cornerRadius + binTol)), length = binLength - (cornerRadius * 2))

 // create the other sides of the bin by using a circular pattern
 sides = patternCircular3d(
@ -53,7 +53,7 @@ sides = patternCircular3d(
    0
  ],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

 // define an axis axis000
@ -68,7 +68,7 @@ axis000 = {
 }

 // create a single corner of the bin
-singleCorner = revolve(face(offsetPlane("YZ", offset = cornerRadius + binTol)), angle = -90, axis = axis000)
+singleCorner = revolve(face(offsetPlane(YZ, offset = cornerRadius + binTol)), angle = -90, axis = axis000)

 // create the corners of the bin
 corners = patternCircular3d(
@ -81,10 +81,10 @@ corners = patternCircular3d(
    0
  ],
  instances = 4,
-  rotateDuplicates = true
+  rotateDuplicates = true,
 )

-singleBinFill = startSketchOn("XY")
+singleBinFill = startSketchOn(XY)
  |> startProfileAt([
       binBaseLength + binTol,
       binBaseLength + binTol
@ -101,7 +101,7 @@ singleBinFill = startSketchOn("XY")
         getPreviousAdjacentEdge(line000),
         getNextAdjacentEdge(line002),
         getPreviousAdjacentEdge(line002)
-       ]
+       ],
     )

 magCutout000 = startSketchOn(singleBinFill, "start")
@ -110,7 +110,7 @@ magCutout000 = startSketchOn(singleBinFill, "start")
         -magOffset - binBaseLength - binTol,
         magOffset + binBaseLength + binTol
       ],
-       radius = magOuterDiam / 2
+       radius = magOuterDiam / 2,
     )
  |> patternCircular2d(
       arcDegrees = 360,
@ -119,7 +119,7 @@ magCutout000 = startSketchOn(singleBinFill, "start")
         (binLength + 2 * binTol) / 2
       ],
       instances = 4,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
  |> extrude(length = -magDepth)

@ -128,42 +128,30 @@ binSides = patternLinear3d(
       sides,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 // create the corners of the baseplate by patterning the corners
 binCorners = patternLinear3d(
       corners,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 // create the fill of the bin by patterning the corners
 binFill = patternLinear3d(
       singleBinFill,
       axis = [1.0, 0.0, 0.0],
       instances = countBinWidth,
-       distance = binLength + binTol * 2
-     )
-  |> patternLinear3d(
-       axis = [0.0, 1.0, 0.0],
-       instances = countBinLength,
-       distance = binLength + binTol * 2
+       distance = binLength + binTol * 2,
     )
+  |> patternLinear3d(axis = [0.0, 1.0, 0.0], instances = countBinLength, distance = binLength + binTol * 2)

 // create the top of the bin
-binTop = startSketchOn(offsetPlane("XY", offset = height))
+binTop = startSketchOn(offsetPlane(XY, offset = height))
  |> startProfileAt([0, 0], %)
  |> xLine(length = (binLength + 2 * binTol) * countBinWidth, tag = $line010)
  |> yLine(length = (binLength + 2 * binTol) * countBinLength, tag = $line011)
@ -177,6 +165,6 @@ binTop = startSketchOn(offsetPlane("XY", offset = height))
         getPreviousAdjacentEdge(line010),
         getNextAdjacentEdge(line012),
         getPreviousAdjacentEdge(line012)
-       ]
+       ],
     )
  |> shell(faces = ["end"], thickness = binThk)
--- a/public/kcl-samples/hex-nut/main.kcl
+++ b/public/kcl-samples/hex-nut/main.kcl
@ -11,7 +11,7 @@ diameter = 0.3125

 // Define a function for the hex nut
 fn hexNut(start, thk, innerDia) {
-  hexNutSketch = startSketchOn('-XZ')
+  hexNutSketch = startSketchOn(-XZ)
    |> startProfileAt([start[0] + innerDia, start[1]], %)
    |> angledLine({ angle = 240, length = innerDia }, %)
    |> angledLine({ angle = 180, length = innerDia }, %)
@ -19,10 +19,7 @@ fn hexNut(start, thk, innerDia) {
    |> angledLine({ angle = 60, length = innerDia }, %)
    |> angledLine({ angle = 0, length = innerDia * .90 }, %)
    |> close()
-    |> hole(circle(
-         center = [start[0], start[1]],
-         radius = innerDia / 2
-       ), %)
+    |> hole(circle(center = [start[0], start[1]], radius = innerDia / 2), %)
    |> extrude(length = thk)
  return hexNutSketch
 }
--- a/public/kcl-samples/keyboard/main.kcl
+++ b/public/kcl-samples/keyboard/main.kcl
@ -19,7 +19,7 @@ row5 = row4 + keyHeight + spacing
 row6 = row5 + keyHeight + spacing

 // Sketch the side profile of the keyboard base and extrude to total width
-sketch001 = startSketchOn('YZ')
+sketch001 = startSketchOn(YZ)
  |> startProfileAt([0, 0], %)
  |> line(end = [-0.14, 0.68], tag = $seg01)
  |> angledLine([7, row6 + 3 * spacing + keyHeight], %, $seg02)
@ -89,7 +89,7 @@ fn keyFn(originStart, keyWidth, keyHeight, repeats, color) {
    |> close()
    |> extrude(length = keyDepth)
    |> appearance(color = color)
-// Repeat key when desired. This will default to zero
+    // Repeat key when desired. This will default to zero
    |> patternLinear3d(
         %,
         instances = repeats + 1,
--- a/public/kcl-samples/kitt/main.kcl
+++ b/public/kcl-samples/kitt/main.kcl
@ -20,7 +20,7 @@ kitBodyWidth = 26
 kitBodyHeight = 25
 kitBodyDepth = 18

-kitBody = startSketchOn('XZ')
+kitBody = startSketchOn(XZ)
  |> startProfileAt([-kitBodyWidth / 2, kitBodyElevation], %)
  |> line(end = [0, kitBodyHeight])
  |> line(end = [kitBodyWidth, 0], tag = $seg01)
@ -159,7 +159,7 @@ kitShoeHeight = 3
 fn kitLeg(offsetFront, offsetSide) {
  kitShoeOffsetFront = kitShoeLength / 2 - (kitBodyDepth / 2) - offsetFront

-  kitFootPrint = startSketchOn('XY')
+  kitFootPrint = startSketchOn(XY)
    |> startProfileAt([offsetSide, kitShoeOffsetFront], %)
    |> line(end = [kitShoeWidth, 0])
    |> line(end = [0, -kitShoeLength])
--- a/public/kcl-samples/lego/main.kcl
+++ b/public/kcl-samples/lego/main.kcl
@ -26,7 +26,7 @@ assertGreaterThan(lbumps, 1, "lbumps must be greater than 1")
 assertGreaterThan(wbumps, 1, "wbumps must be greater than 1")

 // Make the base
-base = startSketchOn('XY')
+base = startSketchOn(XY)
  |> startProfileAt([-totalWidth / 2, -totalLength / 2], %)
  |> line(end = [totalWidth, 0])
  |> line(end = [0, totalLength])
@ -53,18 +53,10 @@ peg = startSketchOn(base, 'end')
         -(pitch * (wbumps - 1) / 2),
         -(pitch * (lbumps - 1) / 2)
       ],
-       radius = bumpDiam / 2
-     )
-  |> patternLinear2d(
-       axis = [1, 0],
-       instances = wbumps,
-       distance = pitch
-     )
-  |> patternLinear2d(
-       axis = [0, 1],
-       instances = lbumps,
-       distance = pitch
+       radius = bumpDiam / 2,
     )
+  |> patternLinear2d(axis = [1, 0], instances = wbumps, distance = pitch)
+  |> patternLinear2d(axis = [0, 1], instances = lbumps, distance = pitch)
  |> extrude(length = bumpHeight)

 // Create the pegs on the bottom of the base
@ -74,16 +66,8 @@ tubePattern = startSketchOn(shellExtrude, 'start')
         -(pitch * (wbumps - 1) / 2 - (pitch / 2)),
         -(pitch * (lbumps - 1) / 2 - (pitch / 2))
       ],
-       radius = bumpDiam / 2
-     )
-  |> patternLinear2d(
-       axis = [1, 0],
-       instances = wbumps - 1,
-       distance = pitch
-     )
-  |> patternLinear2d(
-       axis = [0, 1],
-       instances = lbumps - 1,
-       distance = pitch
+       radius = bumpDiam / 2,
     )
+  |> patternLinear2d(axis = [1, 0], instances = wbumps - 1, distance = pitch)
+  |> patternLinear2d(axis = [0, 1], instances = lbumps - 1, distance = pitch)
  |> extrude(length = bumpHeight)
--- a/public/kcl-samples/mounting-plate/main.kcl
+++ b/public/kcl-samples/mounting-plate/main.kcl
@ -13,7 +13,7 @@ centerHoleDiameter = 2

 // Create a function that defines the body width and length of the mounting plate. Tag the corners so they can be passed through the fillet function.
 fn rectShape(pos, w, l) {
-  rr = startSketchOn('XY')
+  rr = startSketchOn(XY)
    |> startProfileAt([pos[0] - (w / 2), pos[1] - (l / 2)], %)
    |> line(endAbsolute = [pos[0] + w / 2, pos[1] - (l / 2)], tag = $edge1)
    |> line(endAbsolute = [pos[0] + w / 2, pos[1] + l / 2], tag = $edge2)
@ -34,33 +34,30 @@ part = rs
         -plateWidth / 2 + holeIndex,
         plateLength / 2 - holeIndex
       ],
-       radius = holeRadius
+       radius = holeRadius,
     ), %)
  |> hole(circle(
       center = [
         plateWidth / 2 - holeIndex,
         plateLength / 2 - holeIndex
       ],
-       radius = holeRadius
+       radius = holeRadius,
     ), %)
  |> hole(circle(
       center = [
         -plateWidth / 2 + holeIndex,
         -plateLength / 2 + holeIndex
       ],
-       radius = holeRadius
+       radius = holeRadius,
     ), %)
  |> hole(circle(
       center = [
         plateWidth / 2 - holeIndex,
         -plateLength / 2 + holeIndex
       ],
-       radius = holeRadius
-     ), %)
-  |> hole(circle(
-       center = [0, 0],
-       radius = centerHoleDiameter
+       radius = holeRadius,
     ), %)
+  |> hole(circle(center = [0, 0], radius = centerHoleDiameter), %)
  |> extrude(length = plateThickness)
  |> fillet(
       radius = filletRadius,
@ -69,5 +66,5 @@ part = rs
         getPreviousAdjacentEdge(rs.tags.edge2),
         getPreviousAdjacentEdge(rs.tags.edge3),
         getPreviousAdjacentEdge(rs.tags.edge4)
-       ]
+       ],
     )
--- a/public/kcl-samples/multi-axis-robot/globals.kcl
+++ b/public/kcl-samples/multi-axis-robot/globals.kcl
@ -28,37 +28,37 @@ export axisJ3CArmThickness = 2.5

 // Planes
 export plane001 = {
-    plane = {
-      origin = [0.0, 0.0, baseHeight - 1.5 + 0.1],
-      xAxis = [1.0, 0.0, 0.0],
-      yAxis = [0.0, 1.0, 0.0],
-      zAxis = [0.0, 0.0, 1.0]
-    }
+  plane = {
+    origin = [0.0, 0.0, baseHeight - 1.5 + 0.1],
+    xAxis = [1.0, 0.0, 0.0],
+    yAxis = [0.0, 1.0, 0.0],
+    zAxis = [0.0, 0.0, 1.0]
  }
+}

 export plane002 = {
-    plane = {
-      origin = [0.0, 0.0, 0.0],
-      xAxis = [
-        sin(toRadians(axisJ1)),
-        cos(toRadians(axisJ1)),
-        0.0
-      ],
-      yAxis = [0.0, 0.0, 1.0],
-      zAxis = [1.0, 0.0, 0.0]
-    }
+  plane = {
+    origin = [0.0, 0.0, 0.0],
+    xAxis = [
+      sin(toRadians(axisJ1)),
+      cos(toRadians(axisJ1)),
+      0.0
+    ],
+    yAxis = [0.0, 0.0, 1.0],
+    zAxis = [1.0, 0.0, 0.0]
  }
+}

 // Define Plane to Move J2 Axis Robot Arm
 export plane003 = {
-    plane = {
-      origin = [-0.1, 0.0, 0.0],
-      xAxis = [
-        sin(toRadians(axisJ1)),
-        cos(toRadians(axisJ1)),
-        0.0
-      ],
-      yAxis = [0.0, 0.0, 1.0],
-      zAxis = [1.0, 0.0, 0.0]
-    }
-  }
+  plane = {
+    origin = [-0.1, 0.0, 0.0],
+    xAxis = [
+      sin(toRadians(axisJ1)),
+      cos(toRadians(axisJ1)),
+      0.0
+    ],
+    yAxis = [0.0, 0.0, 1.0],
+    zAxis = [1.0, 0.0, 0.0]
+  }
+}
--- a/public/kcl-samples/multi-axis-robot/main.kcl
+++ b/public/kcl-samples/multi-axis-robot/main.kcl
@ -4,10 +4,10 @@
 // Set Units
@settings(defaultLengthUnit = in)

-import 'robot-arm-base.kcl' as robotArmBase
-import 'robot-rotating-base.kcl' as rotatingBase
-import 'robot-arm-j2.kcl' as j2RobotArm
-import 'robot-arm-j3.kcl' as j3RobotArm
+import "robot-arm-base.kcl" as robotArmBase
+import "robot-rotating-base.kcl" as rotatingBase
+import "robot-arm-j2.kcl" as j2RobotArm
+import "robot-arm-j3.kcl" as j3RobotArm

 robotArmBase
 rotatingBase
--- a/public/kcl-samples/multi-axis-robot/robot-arm-base.kcl
+++ b/public/kcl-samples/multi-axis-robot/robot-arm-base.kcl
@ -1,15 +1,13 @@
 // Robot Arm Base

-
 // Set Units
@settings(defaultLengthUnit = in)

-
 // Import Constants
 import basePlateRadius, basePlateThickness, baseChamfer, baseHeight from "globals.kcl"

 // Base Plate
-sketch001 = startSketchOn('XY')
+sketch001 = startSketchOn(XY)
  |> startProfileAt([-basePlateRadius, -basePlateRadius], %)
  |> angledLine([0, 2 * basePlateRadius], %, $rectangleSegmentA001)
  |> angledLine([
@ -30,17 +28,14 @@ extrude001 = extrude(sketch001, length = basePlateThickness)
         getNextAdjacentEdge(rectangleSegmentB001),
         getNextAdjacentEdge(rectangleSegmentC001),
         getNextAdjacentEdge(rectangleSegmentD001)
-       ]
+       ],
     )

 // Base Motor for actuating first joint
 sketch002 = startSketchOn(extrude001, 'END')
  |> circle(center = [0, 0], radius = 4, tag = $referenceEdge)
 extrude002 = extrude(sketch002, length = baseHeight - basePlateThickness - 1.5)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge)]
-     )
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge)])
 sketch003 = startSketchOn(extrude002, 'END')
  |> circle(center = [0, 0], radius = 0.5)
 extrude003 = extrude(sketch003, length = 1)
@ -52,13 +47,13 @@ sketch4A = startSketchOn(extrude001, 'END')
         -basePlateRadius + 1,
         -basePlateRadius + baseChamfer + 0.5
       ],
-       radius = 0.4
+       radius = 0.4,
     )
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = 4,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude4A = extrude(sketch4A, length = -basePlateThickness)
@ -69,13 +64,13 @@ sketch4B = startSketchOn(extrude001, 'END')
         -basePlateRadius + 0.5 + baseChamfer,
         -basePlateRadius + 1
       ],
-       radius = 0.4
+       radius = 0.4,
     )
  |> patternCircular2d(
       arcDegrees = 360,
       center = [0, 0],
       instances = 4,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude(sketch4B, length = -basePlateThickness)
--- a/public/kcl-samples/multi-axis-robot/robot-arm-j2.kcl
+++ b/public/kcl-samples/multi-axis-robot/robot-arm-j2.kcl
@ -1,10 +1,8 @@
 // J2 Axis for Robot Arm

-
 // Set Units
@settings(defaultLengthUnit = in)

-
 import axisJ1, axisJ2, axisJ2ArmWidth, axisJ2ArmLength, axisJ2ArmThickness, plane003 from "globals.kcl"

 // Create Body of J2 Robot Arm
@ -35,24 +33,19 @@ sketch012 = startSketchOn(extrude011, 'START')
  |> circle(center = [-1.75, 8], radius = 1.9, tag = $referenceEdge4)

 extrude012 = extrude(sketch012, length = 0.15)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge4)]
-     )
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge4)])
 sketch013 = startSketchOn(extrude011, 'START')
  |> circle(
-     center = [
+       center = [
         -1.75 - (axisJ2ArmLength * cos(toRadians(axisJ2))),
         8 + axisJ2ArmLength * sin(toRadians(axisJ2))
       ],
-     radius = 1.9,
-     tag = $referenceEdge5)
+       radius = 1.9,
+       tag = $referenceEdge5,
+     )

 extrude013 = extrude(sketch013, length = 1)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge5)]
-     )
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge5)])

 // Draw Bolt Patterns on J2 Robot Arm
 sketch014 = startSketchOn(extrude012, 'END')
@ -61,7 +54,7 @@ sketch014 = startSketchOn(extrude012, 'END')
       center = [-1.75, 8],
       instances = 8,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude014 = extrude(sketch014, length = 0.15)
@ -72,7 +65,7 @@ sketch015 = startSketchOn(extrude013, 'END')
         -1.75 - ((axisJ2ArmLength - 1) * cos(toRadians(axisJ2))),
         8 + (axisJ2ArmLength - 1.5) * sin(toRadians(axisJ2))
       ],
-       radius = 0.2
+       radius = 0.2,
     )
  |> patternCircular2d(
       center = [
@ -81,7 +74,7 @@ sketch015 = startSketchOn(extrude013, 'END')
       ],
       instances = 4,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude015 = extrude(sketch015, length = 0.15)
@ -92,7 +85,7 @@ sketch016 = startSketchOn(extrude011, 'END')
         1.75 + axisJ2ArmLength * cos(toRadians(axisJ2)),
         8 + axisJ2ArmLength * sin(toRadians(axisJ2))
       ],
-       radius = 0.3
+       radius = 0.3,
     )

 extrude(sketch016, length = 1)
--- a/public/kcl-samples/multi-axis-robot/robot-arm-j3.kcl
+++ b/public/kcl-samples/multi-axis-robot/robot-arm-j3.kcl
@ -1,10 +1,8 @@
 // J3 Robot Arm

-
 // Set Units
@settings(defaultLengthUnit = in)

-
 import plane002, axisJ2, axisJ3C, axisJ4, axisJ2ArmLength, axisJ3CArmLength, axisJ3CArmWidth, axisJ3CArmThickness from "globals.kcl"

 // Create Body of J3 Robot Arm
@ -38,13 +36,11 @@ sketch018 = startSketchOn(extrude017, 'END')
         8 + axisJ2ArmLength * sin(toRadians(axisJ2))
       ],
       radius = 3.7 / 2,
-     tag = $referenceEdge6)
+       tag = $referenceEdge6,
+     )

 extrude018 = extrude(sketch018, length = 0.15)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge6)]
-     )
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge6)])

 // Draw Bolt Pattern on J3 Robot Arm
 sketch019 = startSketchOn(extrude018, 'END')
@ -53,7 +49,7 @@ sketch019 = startSketchOn(extrude018, 'END')
         1.75 + (axisJ2ArmLength - 1) * cos(toRadians(axisJ2)),
         8 + (axisJ2ArmLength - 1.5) * sin(toRadians(axisJ2))
       ],
-       radius = 0.2
+       radius = 0.2,
     )
  |> patternCircular2d(
       center = [
@ -62,7 +58,7 @@ sketch019 = startSketchOn(extrude018, 'END')
       ],
       instances = 8,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )

 extrude019 = extrude(sketch019, length = 0.15)
@ -74,7 +70,7 @@ sketch020 = startSketchOn(extrude017, 'START')
         -1.75 - (axisJ2ArmLength * cos(toRadians(axisJ2))) - (axisJ3CArmLength * cos(toRadians(axisJ3C))),
         8 + axisJ2ArmLength * sin(toRadians(axisJ2)) + axisJ3CArmLength * sin(toRadians(axisJ3C))
       ],
-       radius = axisJ3CArmWidth / 2
+       radius = axisJ3CArmWidth / 2,
     )
 extrude020 = extrude(sketch020, length = -0.5)

@ -84,7 +80,7 @@ sketch021 = startSketchOn(extrude017, 'END')
         1.75 + axisJ2ArmLength * cos(toRadians(axisJ2)) + axisJ3CArmLength * cos(toRadians(axisJ3C)),
         8 + axisJ2ArmLength * sin(toRadians(axisJ2)) + axisJ3CArmLength * sin(toRadians(axisJ3C))
       ],
-       radius = axisJ3CArmWidth / 2.01
+       radius = axisJ3CArmWidth / 2.01,
     )

 extrude021 = extrude(sketch021, length = -0.5)
--- a/public/kcl-samples/multi-axis-robot/robot-rotating-base.kcl
+++ b/public/kcl-samples/multi-axis-robot/robot-rotating-base.kcl
@ -1,20 +1,15 @@
 // Robot Rotating Base

-
 // Set Units
@settings(defaultLengthUnit = in)

-
 import axisJ1, baseHeight, plane001, plane002 from "globals.kcl"

 // Create Rotating Base
 sketch005 = startSketchOn(plane001)
  |> circle(center = [0, 0], radius = 3.9, tag = $referenceEdge1)
 extrude005 = extrude(sketch005, length = 1.5 - 0.1)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge1)]
-     )
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge1)])
  |> appearance(color = "#4f7d54", metalness = 90, roughness = 90)

 sketch006 = startSketchOn(plane002)
@ -38,12 +33,10 @@ sketch007 = startSketchOn(extrude006, 'END')
         8
       ],
       radius = 2.75,
-       tag = $referenceEdge2)
-extrude007 = extrude(sketch007, length = 1.5)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge2)]
+       tag = $referenceEdge2,
     )
+extrude007 = extrude(sketch007, length = 1.5)
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge2)])

 // Draw Bolt Pattern on Rotating Base
 sketch008 = startSketchOn(extrude007, 'END')
@ -52,7 +45,7 @@ sketch008 = startSketchOn(extrude007, 'END')
         1.75 * cos(toRadians(axisJ1)) / abs(cos(toRadians(axisJ1))),
         6.75
       ],
-       radius = 0.2
+       radius = 0.2,
     )
  |> patternCircular2d(
       center = [
@ -61,7 +54,7 @@ sketch008 = startSketchOn(extrude007, 'END')
       ],
       instances = 4,
       arcDegrees = 360,
-       rotateDuplicates = true
+       rotateDuplicates = true,
     )
 extrude008 = extrude(sketch008, length = 0.2)

@ -72,12 +65,10 @@ sketch009 = startSketchOn(extrude007, 'END')
         8
       ],
       radius = 0.5,
-     tag = $referenceEdge3)
-extrude009 = extrude(sketch009, length = 0.15)
-  |> fillet(
-       radius = 0.1,
-       tags = [getOppositeEdge(referenceEdge3)]
+       tag = $referenceEdge3,
     )
+extrude009 = extrude(sketch009, length = 0.15)
+  |> fillet(radius = 0.1, tags = [getOppositeEdge(referenceEdge3)])
  |> appearance(color = "#4f7d54", metalness = 90, roughness = 90)

 sketch010 = startSketchOn(plane002)
--- a/public/kcl-samples/pipe-flange-assembly/1120t74-pipe.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/1120t74-pipe.kcl
@ -1,16 +1,16 @@
-// 1120t74 Pipe
-
-// import constants
-import pipeInnerDiameter, pipeOuterDiameter, pipeLength from "globals.kcl"
+// Pipe
+// piping for the pipe flange assembly

 // set units
@settings(defaultLengthUnit = in)

+// import constants
+import pipeInnerDiameter, pipeOuterDiameter, pipeLength from "globals.kcl"
+
 // create a function to make the pipe
 export fn pipe() {
-
  // create the pipe base
-  pipeBase = startSketchOn('XZ')
+  pipeBase = startSketchOn(XZ)
    |> circle(%, center = [0, 0], radius = pipeOuterDiameter / 2)
    |> extrude(%, length = pipeLength)

--- a/public/kcl-samples/pipe-flange-assembly/68095k348-flange.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/68095k348-flange.kcl
@ -1,16 +1,16 @@
 // 68095k348 flange
-
-// import constants
-import pipeDiameter, mountingHoleDiameter, mountingHolePlacementDiameter, flangeDiameter, flangeTotalThickness, flangeBackHeight, flangeFrontHeight, flangeBaseThickness, flangeBackDiameter, flangeFrontDiameter from "globals.kcl"
+// flange used for mating two pipes together in the pipe flange assembly.

 // set units
@settings(defaultLengthUnit = in)

+// import constants
+import pipeDiameter, mountingHoleDiameter, mountingHolePlacementDiameter, flangeDiameter, flangeTotalThickness, flangeBackHeight, flangeFrontHeight, flangeBaseThickness, flangeBackDiameter, flangeFrontDiameter from "globals.kcl"
+
 // create a function to create the flange
 export fn flange() {
-
  // sketch the mounting hole pattern
-  mountingHoles = startSketchOn("XY")
+  mountingHoles = startSketchOn(XY)
    |> circle(%, center = [0, mountingHolePlacementDiameter / 2], radius = mountingHoleDiameter / 2)
    |> patternCircular2d(
         %,
@ -21,7 +21,7 @@ export fn flange() {
       )

  // create the flange base
-  flangeBase = startSketchOn("XY")
+  flangeBase = startSketchOn(XY)
    |> circle(%, center = [0, 0], radius = flangeDiameter / 2)
    |> hole(mountingHoles, %)
    |> extrude(%, length = flangeBaseThickness)
--- a/public/kcl-samples/pipe-flange-assembly/91251a404-bolt.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/91251a404-bolt.kcl
@ -1,16 +1,17 @@
 // 91251A404 Socket Head Cap Screw
-
-// import constants
-import boltDiameter, boltLength, boltHeadLength, boltHeadDiameter, boltHexDrive, boltHexFlatLength, boltThreadLength from "globals.kcl"
+// screw for mating the flanges together in the pipe flange assembly

 // set units
@settings(defaultLengthUnit = in)

+
+// import constants
+import boltDiameter, boltLength, boltHeadLength, boltHeadDiameter, boltHexDrive, boltHexFlatLength, boltThreadLength from "globals.kcl"
+
 // create a function to make a the bolt
 export fn bolt() {
-
  // Create the head of the cap screw
-  boltHead = startSketchOn('XZ')
+  boltHead = startSketchOn(XZ)
    |> circle(center = [0, 0], radius = boltHeadDiameter / 2, tag = $topEdge)
    |> extrude(length = -boltHeadLength)
    |> fillet(radius = 0.020, tags = [topEdge, getOppositeEdge(topEdge)])
--- a/public/kcl-samples/pipe-flange-assembly/9472k188-gasket.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/9472k188-gasket.kcl
@ -1,16 +1,16 @@
 // 9472K188 Gasket
-
-// import constants
-import gasketOutsideDiameter, gasketInnerDiameter, gasketThickness from "globals.kcl"
+// gasket for the pipe flange assembly. A gasket is a mechanical seal that fills the space between two or more mating surfaces, preventing leaks of liquids or gases under compression

 // set units
@settings(defaultLengthUnit = in)

+// import constants
+import gasketOutsideDiameter, gasketInnerDiameter, gasketThickness from "globals.kcl"
+
 // create a function to make the gasket
 export fn gasket() {
-
  // create the base of the gasket
-  gasketBase = startSketchOn("XY")
+  gasketBase = startSketchOn(XY)
    |> circle(%, center = [0, 0], radius = gasketOutsideDiameter / 2)
    |> extrude(%, length = gasketThickness)

--- a/public/kcl-samples/pipe-flange-assembly/95479a127-hex-nut.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/95479a127-hex-nut.kcl
@ -1,16 +1,16 @@
 // 95479A127 Hex Nut
-
-// import constants
-import hexNutDiameter, hexNutFlatToFlat, hexNutThickness, hexNutFlatLength from "globals.kcl"
+// hex nut for the screws in the pipe flange assembly.

 // set units
@settings(defaultLengthUnit = in)

+// import constants
+import hexNutDiameter, hexNutFlatToFlat, hexNutThickness, hexNutFlatLength from "globals.kcl"
+
 // create a function to make the hex nut
 export fn hexNut() {
-
  // create the base of the hex nut
-  hexNutBase = startSketchOn('XY')
+  hexNutBase = startSketchOn(XY)
    |> startProfileAt([
         hexNutFlatToFlat / 2,
         hexNutFlatLength / 2
--- a/public/kcl-samples/pipe-flange-assembly/98017a257-washer.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/98017a257-washer.kcl
@ -1,16 +1,16 @@
 // 98017A257 Washer
-
-// import constants
-import washerInnerDia, washerOuterDia, washerThickness from "globals.kcl"
+// washer for the screws in the pipe flange assembly. 

 // set units
@settings(defaultLengthUnit = in)

+// import constants
+import washerInnerDia, washerOuterDia, washerThickness from "globals.kcl"
+
 // create a function to make the washer
 export fn washer() {
-
  // create the base of the washer
-  washerBase = startSketchOn('XY')
+  washerBase = startSketchOn(XY)
    |> circle(center = [0, 0], radius = washerOuterDia / 2)
    |> extrude(length = washerThickness)

--- a/public/kcl-samples/pipe-flange-assembly/main.kcl
+++ b/public/kcl-samples/pipe-flange-assembly/main.kcl
@ -5,54 +5,120 @@
@settings(defaultLengthUnit = in)

 // import constants
-import * from 'globals.kcl'
+import * from "globals.kcl"

 // import parts
-import flange from '68095k348-flange.kcl'
-import gasket from '9472k188-gasket.kcl'
-import washer from '98017a257-washer.kcl'
-import bolt from '91251a404-bolt.kcl'
-import hexNut from '95479a127-hex-nut.kcl'
-import pipe from '1120t74-pipe.kcl'
+import flange from "68095k348-flange.kcl"
+import gasket from "9472k188-gasket.kcl"
+import washer from "98017a257-washer.kcl"
+import bolt from "91251a404-bolt.kcl"
+import hexNut from "95479a127-hex-nut.kcl"
+import pipe from "1120t74-pipe.kcl"

 // place flanges
 flange()
 flange()
  |> rotate(axis = [0, 1, 0], angle = 180)
-  |> translate(translate = [0, 0, flangeBackHeight*2 + gasketThickness])
+  |> translate(translate = [
+       0,
+       0,
+       flangeBackHeight * 2 + gasketThickness
+     ])

 // place gasket between the flanges
 gasket()
-  |> translate(translate = [0, 0, -flangeBackHeight - gasketThickness])
+  |> translate(translate = [
+       0,
+       0,
+       -flangeBackHeight - gasketThickness
+     ])

 // place eight washers (four front, four back)
 washer()
  |> translate(translate = [
-    mountingHolePlacementDiameter/2, 
-    0, 
-    flangeBaseThickness
-  ])
-  |> patternCircular3d(%, instances = 4, axis = [0, 0, 1], center = [0, 0, 0], arcDegrees = 360, rotateDuplicates = false)
-  |> patternLinear3d(%, instances = 2, distance = -(flangeBaseThickness*2 + flangeBackHeight * 2 + gasketThickness + washerThickness), axis = [0, 0, 1])
+       mountingHolePlacementDiameter / 2,
+       0,
+       flangeBaseThickness
+     ])
+  |> patternCircular3d(
+       %,
+       instances = 4,
+       axis = [0, 0, 1],
+       center = [0, 0, 0],
+       arcDegrees = 360,
+       rotateDuplicates = false,
+     )
+  |> patternLinear3d(
+       %,
+       instances = 2,
+       distance = -(flangeBaseThickness * 2 + flangeBackHeight * 2 + gasketThickness + washerThickness),
+       axis = [0, 0, 1],
+     )

 // place four bolts
 bolt()
  |> translate(translate = [
-    mountingHolePlacementDiameter/2, 0, flangeBaseThickness + washerThickness
-  ])
+       mountingHolePlacementDiameter / 2,
+       0,
+       flangeBaseThickness + washerThickness
+     ])
  |> rotate(roll = 90, pitch = 0, yaw = 0)
-  |> patternCircular3d(%, instances = 4, axis = [0, 0, 1], center = [0, 0, 0], arcDegrees = 360, rotateDuplicates = false)
+  |> patternCircular3d(
+       %,
+       instances = 4,
+       axis = [0, 0, 1],
+       center = [0, 0, 0],
+       arcDegrees = 360,
+       rotateDuplicates = false,
+     )

 // place four hex nuts
 hexNut()
-  |> translate(translate = [mountingHolePlacementDiameter/2, 0, -(flangeBackHeight * 2 + gasketThickness + flangeBaseThickness + washerThickness + hexNutThickness)])
-  |> patternCircular3d(%, instances = 4, axis = [0, 0, 1], center = [0, 0, 0], arcDegrees = 360, rotateDuplicates = false)
+  |> translate(translate = [
+       mountingHolePlacementDiameter / 2,
+       0,
+       -(flangeBackHeight * 2 + gasketThickness + flangeBaseThickness + washerThickness + hexNutThickness)
+     ])
+  |> patternCircular3d(
+       %,
+       instances = 4,
+       axis = [0, 0, 1],
+       center = [0, 0, 0],
+       arcDegrees = 360,
+       rotateDuplicates = false,
+     )

 // place both pieces of pipe
 pipe()
-  |> rotate(%, roll = -90, pitch = 0, yaw = 0)
-  |> translate(%, translate = [0, 0, flangeBaseThickness + flangeFrontHeight - 0.5], global = true)
+  |> rotate(
+       %,
+       roll = -90,
+       pitch = 0,
+       yaw = 0,
+     )
+  |> translate(
+       %,
+       translate = [
+         0,
+         0,
+         flangeBaseThickness + flangeFrontHeight - 0.5
+       ],
+       global = true,
+     )

 pipe()
-  |> rotate(%, roll = 90, pitch = 0, yaw = 0)
-  |> translate(%, translate = [0, 0, -(flangeBackHeight * 2 + gasketThickness + flangeBaseThickness  + flangeFrontHeight - 0.5)], global = true)
+  |> rotate(
+       %,
+       roll = 90,
+       pitch = 0,
+       yaw = 0,
+     )
+  |> translate(
+       %,
+       translate = [
+         0,
+         0,
+         -(flangeBackHeight * 2 + gasketThickness + flangeBaseThickness + flangeFrontHeight - 0.5)
+       ],
+       global = true,
+     )
--- a/public/kcl-samples/pipe-with-bend/main.kcl
+++ b/public/kcl-samples/pipe-with-bend/main.kcl
@ -1,7 +1,6 @@
 // Pipe with bend
 // A tubular section or hollow cylinder, usually but not necessarily of circular cross-section, used mainly to convey substances that can flow.

-
 // Set units
@settings(defaultLengthUnit = in)

@ -12,7 +11,7 @@ bendRadius = 30
 bendAngle = 90

 // create a sketch in the 'XZ' plane
-sketch000 = startSketchOn("XZ")
+sketch000 = startSketchOn(XZ)

 // create a profile for the outer diameter
 outerProfile = circle(sketch000, center = [bendRadius, 0], radius = outerDiameter / 2)
--- a/public/kcl-samples/pipe/main.kcl
+++ b/public/kcl-samples/pipe/main.kcl
@ -15,7 +15,7 @@ pipeTransitionLength = 0.5
 pipeSmallDiaLength = pipeTotalLength - pipeTransitionLength - pipeLargeDiaLength

 // Create the sketch to be revolved around the y-axis. Use the small diameter, large diameter, length, and thickness to define the sketch.
-pipeSketch = startSketchOn('XY')
+pipeSketch = startSketchOn(XY)
  |> startProfileAt([pipeSmallDia - (thickness / 2), 38], %)
  |> line(end = [thickness, 0])
  |> line(end = [0, -pipeSmallDiaLength])
--- a/public/kcl-samples/poopy-shoe/main.kcl
+++ b/public/kcl-samples/poopy-shoe/main.kcl
@ -1,11 +1,9 @@
 // Poopy Shoe
 // poop shute for bambu labs printer - optimized for printing.

-
 // Set units
@settings(defaultLengthUnit = in)

-
 wallThickness = 0.125
 wallsWidth = 3
 height = 5.125
@ -14,7 +12,7 @@ backLength = 6
 exitHeight = 1
 frontLength = 7

-sketch001 = startSketchOn("-YZ")
+sketch001 = startSketchOn(-YZ)
  |> startProfileAt([wallsWidth / 2, 0], %)
  |> xLine(length = wallThickness / 2)
  |> angledLineToX({ angle = 60, to = wallsWidth }, %, $seg01)
@ -32,17 +30,18 @@ sketch001 = startSketchOn("-YZ")
  |> yLine(endAbsolute = segEndY(seg01))
  |> angledLineToY({ angle = 180 - 60, to = 0 }, %)
  |> close()
-part001 = revolve(sketch001, 
+part001 = revolve(
+  sketch001,
  angle = 90,
  axis = {
    custom = {
      axis = [1.0, 0.0],
      origin = [0.0, height + .0001]
    }
-  }
+  },
 )

-sketch002 = startSketchOn('-YZ')
+sketch002 = startSketchOn(-YZ)
  |> startProfileAt([wallsWidth / 2, 0], %)
  |> xLine(length = wallThickness / 2)
  |> angledLineToX({ angle = 60, to = wallsWidth }, %, $seg02)
--- a/public/kcl-samples/router-template-cross-bar/main.kcl
+++ b/public/kcl-samples/router-template-cross-bar/main.kcl
@ -13,7 +13,7 @@ templateThickness = 10
 radius = 10
 depth = 30
 distanceToInsideEdge = slateWidthHalf + templateThickness + templateGap
-sketch001 = startSketchOn('XZ')
+sketch001 = startSketchOn(XZ)
  |> startProfileAt([ZERO, depth + templateGap], %)
  |> xLine(length = slateWidthHalf - radius, tag = $seg01)
  |> arc({
--- a/public/kcl-samples/router-template-slate/main.kcl
+++ b/public/kcl-samples/router-template-slate/main.kcl
@ -17,7 +17,7 @@ length001 = slateWidthHalf - radius
 length002 = depth + minClampingDistance

 // Create the first sketch
-sketch001 = startSketchOn('XZ')
+sketch001 = startSketchOn(XZ)
  |> startProfileAt([0, depth - templateGap], %)
  |> xLine(length = length001, tag = $seg01)
  |> arc({
--- a/public/kcl-samples/screenshots/color-cube.png
+++ b/public/kcl-samples/screenshots/color-cube.png
--- a/public/kcl-samples/sheet-metal-bracket/main.kcl
+++ b/public/kcl-samples/sheet-metal-bracket/main.kcl
@ -15,7 +15,7 @@ boltSize = 0.25
 flangeWidth = 1.5

 // Sketch and extrude the base shape and fillet the inside and outside edges.
-baseExtrusion = startSketchOn('-XZ')
+baseExtrusion = startSketchOn(-XZ)
  |> startProfileAt([0, 0], %)
  |> line(end = [0, thickness], tag = $e1)
  |> line(end = [flangeLength, 0], tag = $e2)
@ -30,82 +30,46 @@ baseExtrusion = startSketchOn('-XZ')
  |> line(end = [0, -hatHeight], tag = $e11)
  |> close(tag = $e12)
  |> extrude(length = hatWidth)
-  |> fillet(
-       radius = bendRad,
-       tags = [getNextAdjacentEdge(e2)]
-     )
-  |> fillet(
-       radius = outsideBendRad,
-       tags = [getNextAdjacentEdge(e3)]
-     )
-  |> fillet(
-       radius = outsideBendRad,
-       tags = [getNextAdjacentEdge(e4)]
-     )
-  |> fillet(
-       radius = bendRad,
-       tags = [getNextAdjacentEdge(e5)]
-     )
-  |> fillet(
-       radius = outsideBendRad,
-       tags = [getNextAdjacentEdge(e8)]
-     )
-  |> fillet(
-       radius = bendRad,
-       tags = [getNextAdjacentEdge(e9)]
-     )
-  |> fillet(
-       radius = bendRad,
-       tags = [getNextAdjacentEdge(e10)]
-     )
-  |> fillet(
-       radius = outsideBendRad,
-       tags = [getNextAdjacentEdge(e11)]
-     )
+  |> fillet(radius = bendRad, tags = [getNextAdjacentEdge(e2)])
+  |> fillet(radius = outsideBendRad, tags = [getNextAdjacentEdge(e3)])
+  |> fillet(radius = outsideBendRad, tags = [getNextAdjacentEdge(e4)])
+  |> fillet(radius = bendRad, tags = [getNextAdjacentEdge(e5)])
+  |> fillet(radius = outsideBendRad, tags = [getNextAdjacentEdge(e8)])
+  |> fillet(radius = bendRad, tags = [getNextAdjacentEdge(e9)])
+  |> fillet(radius = bendRad, tags = [getNextAdjacentEdge(e10)])
+  |> fillet(radius = outsideBendRad, tags = [getNextAdjacentEdge(e11)])

 // Define the flanges and place the bolt holes
-flange1 = startSketchOn('XY')
+flange1 = startSketchOn(XY)
  |> startProfileAt([0, 0], %)
  |> line(end = [0, hatWidth])
  |> line(end = [flangeWidth, 0], tag = $e13)
  |> line(end = [0, -hatWidth], tag = $e14)
  |> close()
-  |> hole(circle(
-       center = [0.75, 1],
-       radius = boltSize
-     ), %)
-  |> hole(circle(
-       center = [0.75, 4],
-       radius = boltSize
-     ), %)
+  |> hole(circle(center = [0.75, 1], radius = boltSize), %)
+  |> hole(circle(center = [0.75, 4], radius = boltSize), %)
  |> extrude(length = thickness)
  |> fillet(
       radius = 0.5,
       tags = [
         getNextAdjacentEdge(e13),
         getNextAdjacentEdge(e14)
-       ]
+       ],
     )

-flange2 = startSketchOn('XY')
+flange2 = startSketchOn(XY)
  |> startProfileAt([-6, 0], %)
  |> line(end = [0, hatWidth])
  |> line(end = [-flangeWidth, 0], tag = $e15)
  |> line(end = [0, -hatWidth], tag = $e16)
  |> close()
-  |> hole(circle(
-       center = [-6.75, 1],
-       radius = boltSize
-     ), %)
-  |> hole(circle(
-       center = [-6.75, 4],
-       radius = boltSize
-     ), %)
+  |> hole(circle(center = [-6.75, 1], radius = boltSize), %)
+  |> hole(circle(center = [-6.75, 4], radius = boltSize), %)
  |> extrude(length = thickness)
  |> fillet(
       radius = 0.25,
       tags = [
         getNextAdjacentEdge(e15),
         getNextAdjacentEdge(e16)
-       ]
+       ],
     )
--- a/public/kcl-samples/socket-head-cap-screw/main.kcl
+++ b/public/kcl-samples/socket-head-cap-screw/main.kcl
@ -5,24 +5,19 @@
@settings(defaultLengthUnit = in, defaultAngleUnit = deg)

 export boltDiameter = 0.190
-export boltLength = 1.00
+export boltLength = 1.0
 export boltHeadLength = boltDiameter
 export boltHeadDiameter = 0.313
-export boltHexDrive = 5/32
+export boltHexDrive = 5 / 32
 export boltHexFlatLength = boltHexDrive / (2 * cos(toRadians(30)))

-export fn bolt () {
-  
+export fn bolt() {
  // Create the head of the cap screw
-  boltHead = startSketchOn('XZ')
-    |> circle(
-         center = [0, 0],
-         radius = boltHeadDiameter / 2,
-         tag = $topEdge
-       )
+  boltHead = startSketchOn(XZ)
+    |> circle(center = [0, 0], radius = boltHeadDiameter / 2, tag = $topEdge)
    |> extrude(length = -boltHeadLength)
    |> fillet(radius = 0.020, tags = [topEdge, getOppositeEdge(topEdge)])
-  
+
  // Define the sketch of the hex pattern on the screw head
  hexPatternSketch = startSketchOn(boltHead, 'start')
    |> startProfileAt([
@ -51,7 +46,6 @@ export fn bolt () {
       }, %)
    |> close()
    |> extrude(length = -boltHeadLength * 0.75)
-  
  boltBody = startSketchOn(boltHead, 'end')
    |> circle(center = [0, 0], radius = boltDiameter / 2, tag = $filletEdge)
    |> extrude(length = boltLength)
--- a/public/kcl-samples/walkie-talkie/antenna.kcl
+++ b/public/kcl-samples/walkie-talkie/antenna.kcl
@ -1,24 +1,23 @@
-// Antenna
-
-
-// import constants
-import antennaLength, antennaBaseWidth, antennaBaseHeight, antennaTopWidth, antennaTopHeight from "globals.kcl"
+// Walkie talkie antenna
+// antenna for the walkie talkie assembly

 // Set units
@settings(defaultLengthUnit = in)

-export fn antenna () {
+// import constants
+import antennaLength, antennaBaseWidth, antennaBaseHeight, antennaTopWidth, antennaTopHeight from "globals.kcl"
+
+export fn antenna() {
  // Create the antenna base sketch
-  sketch001 = startSketchOn('XY')
+  sketch001 = startSketchOn(XY)
    |> startProfileAt([0, 0], %)
    |> line(end = [antennaBaseWidth, 0])
    |> line(end = [0, -antennaBaseHeight])
    |> line(end = [-antennaBaseWidth, 0])
    |> close()
-  
+
  // Create the antenna top sketch
-  loftPlane = offsetPlane('XY', offset = antennaLength)
-  
+  loftPlane = offsetPlane(XY, offset = antennaLength)
  sketch002 = startSketchOn(loftPlane)
    |> startProfileAt([
         (antennaBaseWidth - antennaTopWidth) / 2,
@ -28,10 +27,9 @@ export fn antenna () {
    |> yLine(length = -antennaTopHeight)
    |> xLine(length = -antennaTopWidth)
    |> close()
-  
+
  // Create the antenna using a loft
  antenna = loft([sketch001, sketch002])
    |> appearance(color = "#000000")
  return antenna
-  
 }
--- a/public/kcl-samples/walkie-talkie/body.kcl
+++ b/public/kcl-samples/walkie-talkie/body.kcl
@ -1,16 +1,16 @@
 // Walkie talkie body
-
-// import constants
-import height, width, thickness, chamferLength, offset, screenWidth, screenHeight, screenYPosition, screenDepth, speakerBoxWidth, speakerBoxHeight from "globals.kcl"
+// the main body of the walkie talkie assembly

 // set units
@settings(defaultLengthUnit = in)

-// create a function to define the body
-export fn body () {
+// import constants
+import height, width, thickness, chamferLength, offset, screenWidth, screenHeight, screenYPosition, screenDepth, speakerBoxWidth, speakerBoxHeight from "globals.kcl"

+// create a function to define the body
+export fn body() {
  // sketch and extrude the body of the walkie talkie
-  bodySketch = startSketchOn('XZ')
+  bodySketch = startSketchOn(XZ)
    |> startProfileAt([-width / 2, height / 2], %)
    |> xLine(length = width, tag = $chamfer1)
    |> yLine(length = -height, tag = $chamfer2)
@ -24,7 +24,7 @@ export fn body () {
           getNextAdjacentEdge(chamfer2),
           getNextAdjacentEdge(chamfer3),
           getNextAdjacentEdge(chamfer4)
-         ]
+         ],
       )

  // cut out the indentation for the case
@ -57,7 +57,7 @@ export fn body () {
       }, %)
    |> close()
  extrude002 = extrude(sketch002, length = -0.0625)
-  
+
  // Create the pocket for the screen
  sketch003 = startSketchOn(extrude002, 'start')
    |> startProfileAt([-screenWidth / 2, screenYPosition], %)
@ -67,7 +67,7 @@ export fn body () {
    |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
    |> close()
  extrude003 = extrude(sketch003, length = screenDepth)
-  
+
  // Create the speaker box
  sketch004 = startSketchOn(extrude002, 'start')
    |> startProfileAt([-1.25 / 2, -.125], %)
@ -77,9 +77,7 @@ export fn body () {
    |> close()

  body = extrude(sketch004, length = -.5)
-    |> appearance(
-      color = "#277bb0",
-    )
+    |> appearance(color = "#277bb0")
  return body
 }

--- a/public/kcl-samples/walkie-talkie/button.kcl
+++ b/public/kcl-samples/walkie-talkie/button.kcl
@ -4,26 +4,16 @@
@settings(defaultLengthUnit = in)

 // import constants
-import buttonWidth, buttonHeight, buttonThickness from 'globals.kcl'
+import buttonWidth, buttonHeight, buttonThickness from "globals.kcl"

 // create a function to define the button
 export fn button() {
-
  // sketch the button profile and extrude
-  buttonSketch = startSketchOn('XZ')
+  buttonSketch = startSketchOn(XZ)
    |> startProfileAt([0, 0], %)
-    |> angledLine({
-         angle = 180,
-         length = buttonWidth
-       }, %, $tag1)
-    |> angledLine({
-         angle = 270,
-         length = buttonHeight
-       }, %, $tag2)
-    |> angledLine({
-         angle = 0,
-         length = buttonWidth
-       }, %)
+    |> angledLine({ angle = 180, length = buttonWidth }, %, $tag1)
+    |> angledLine({ angle = 270, length = buttonHeight }, %, $tag2)
+    |> angledLine({ angle = 0, length = buttonWidth }, %)
    |> close()
  buttonExtrude = extrude(buttonSketch, length = buttonThickness)
    |> chamfer(
@ -31,9 +21,9 @@ export fn button() {
         tags = [
           getNextAdjacentEdge(tag1),
           getNextAdjacentEdge(tag2)
-         ]
+         ],
       )
-     |> appearance(color = "#ff0000")
+    |> appearance(color = "#ff0000")

  return buttonExtrude
-}
+}
--- a/public/kcl-samples/walkie-talkie/case.kcl
+++ b/public/kcl-samples/walkie-talkie/case.kcl
@ -1,25 +1,24 @@
 // Walkie talkie case
+// the plastic case for the front of the walkie talkie

+// set units
+@settings(defaultLengthUnit = in)

 // import constants and Zoo logo
 import width, height, chamferLength, offset, screenWidth, screenHeight, screenYPosition, screenDepth, speakerBoxWidth, speakerBoxHeight, squareHoleSideLength, caseTolerance from "globals.kcl"
 import zLogo, oLogo, oLogo2 from "zoo-logo.kcl"

-// set units
-@settings(defaultLengthUnit = in)
-
 // create a function to define the case
-export fn case () {
-
+export fn case() {
  // sketch the profile of the screen
-  sketch006 = startSketchOn(startSketchOn('XZ'))
+  sketch006 = startSketchOn(startSketchOn(XZ))
    |> startProfileAt([-screenWidth / 2, screenYPosition], %)
    |> xLine(length = screenWidth)
    |> yLine(length = -screenHeight)
    |> xLine(length = -screenWidth)
    |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
    |> close()
-  
+
  // create transform functions for the speaker grid pattern
  fn transformX(i) {
    return { translate = [.125 * i, 0] }
@ -29,7 +28,7 @@ export fn case () {
  }

  // sketch the square hole grid pattern
-  squareHolePatternSketch = startSketchOn(startSketchOn('XZ'))
+  squareHolePatternSketch = startSketchOn(startSketchOn(XZ))
    |> startProfileAt([-screenWidth / 2 + .100, 0], %)
    |> line(end = [squareHoleSideLength / 2, 0])
    |> line(end = [0, -squareHoleSideLength / 2])
@ -38,8 +37,8 @@ export fn case () {
    |> patternTransform2d(instances = 13, transform = transformX)
    |> patternTransform2d(instances = 11, transform = transformY)

-  // sketch the outer profile of the case and extrude with holes using the previously made profiles  
-  sketch005 = startSketchOn(startSketchOn('XZ'))
+  // sketch the outer profile of the case and extrude with holes using the previously made profiles
+  sketch005 = startSketchOn(startSketchOn(XZ))
    |> startProfileAt([
         -width / 2 + offset + caseTolerance,
         height / 2 - (chamferLength + (offset + caseTolerance) / 2 * cos(toRadians(45)))
@ -77,14 +76,13 @@ export fn case () {
    |> hole(squareHolePatternSketch, %)

    // create the Zoo logo
-    |> hole(zLogo(startSketchOn('XZ'), [-.30, -1.825], .20), %)
-    |> hole(oLogo(startSketchOn('XZ'), [-.075, -1.825], .20), %)
-    |> hole(oLogo2(startSketchOn('XZ'), [-.075, -1.825], .20), %)
-    |> hole(oLogo(startSketchOn('XZ'), [.175, -1.825], .20), %)
-    |> hole(oLogo2(startSketchOn('XZ'), [.175, -1.825], .20), %)
-  
+    |> hole(zLogo(startSketchOn(XZ), [-.30, -1.825], .20), %)
+    |> hole(oLogo(startSketchOn(XZ), [-.075, -1.825], .20), %)
+    |> hole(oLogo2(startSketchOn(XZ), [-.075, -1.825], .20), %)
+    |> hole(oLogo(startSketchOn(XZ), [.175, -1.825], .20), %)
+    |> hole(oLogo2(startSketchOn(XZ), [.175, -1.825], .20), %)
  case = extrude(sketch005, length = -0.0625)
    |> appearance(color = '#D0FF01', metalness = 0, roughness = 50)

  return case
-}
+}
--- a/public/kcl-samples/walkie-talkie/globals.kcl
+++ b/public/kcl-samples/walkie-talkie/globals.kcl
@ -40,4 +40,4 @@ export knobRadius = 0.050

 // talk-button
 export talkButtonSideLength = 0.5
-export talkButtonHeight = 0.050
+export talkButtonHeight = 0.050
--- a/public/kcl-samples/walkie-talkie/knob.kcl
+++ b/public/kcl-samples/walkie-talkie/knob.kcl
@ -1,31 +1,28 @@
-// Walkie Talkie Frequency Knob
-
-// import constants
-import width, thickness, height, knobDiameter, knobHeight, knobRadius from "globals.kcl"
+// Walkie talkie frequency knob
+// the frequency knob for the walkie talkie assembly

 // set units
@settings(defaultLengthUnit = in)

-// create a function to define the knob
-export fn knob () {
+// import constants
+import width, thickness, height, knobDiameter, knobHeight, knobRadius from "globals.kcl"

-// Create the knob sketch and revolve
-knob = startSketchOn('XZ')
-  |> startProfileAt([0.0001, 0], %)
-  |> xLine(length = knobDiameter / 2)
-  |> yLine(length = knobHeight - 0.05)
-  |> arc({
-       angleStart = 0,
-       angleEnd = 90,
-       radius = .05
-     }, %)
-  |> xLine(endAbsolute = 0.0001)
-  |> close()
-  |> revolve(
-    axis = "Y",
-  )
-  |> appearance(color = '#D0FF01', metalness = 90, roughness = 50)
+// create a function to define the knob
+export fn knob() {
+  // Create the knob sketch and revolve
+  knob = startSketchOn(XZ)
+    |> startProfileAt([0.0001, 0], %)
+    |> xLine(length = knobDiameter / 2)
+    |> yLine(length = knobHeight - 0.05)
+    |> arc({
+         angleStart = 0,
+         angleEnd = 90,
+         radius = .05
+       }, %)
+    |> xLine(endAbsolute = 0.0001)
+    |> close()
+    |> revolve(axis = "Y")
+    |> appearance(color = '#D0FF01', metalness = 90, roughness = 50)

  return knob
-
-}
+}
--- a/public/kcl-samples/walkie-talkie/main.kcl
+++ b/public/kcl-samples/walkie-talkie/main.kcl
@ -5,14 +5,14 @@
@settings(defaultLengthUnit = in)

 // import constants
-import * from 'globals.kcl'
+import * from "globals.kcl"

 // import parts and constants
-import body from 'body.kcl'
-import case from 'case.kcl'
-import antenna from 'antenna.kcl'
-import talkButton from 'talk-button.kcl'
-import knob from 'knob.kcl'
+import body from "body.kcl"
+import case from "case.kcl"
+import antenna from "antenna.kcl"
+import talkButton from "talk-button.kcl"
+import knob from "knob.kcl"
 import button from "button.kcl"

 // import the body
@ -20,7 +20,7 @@ body()

 // import the antenna
 antenna()
-  |> translate(translate = [-width / 2 + .45, -0.10, height/2])
+  |> translate(translate = [-width / 2 + .45, -0.10, height / 2])

 // import the case
 case()
@ -32,16 +32,52 @@ talkButton()

 // import the frequency knob
 knob()
-  |> translate(translate = [width / 2 - 0.70, -thickness / 2, height / 2])
+  |> translate(translate = [
+       width / 2 - 0.70,
+       -thickness / 2,
+       height / 2
+     ])

 // import the buttons
 button()
-  |> translate(translate = [-(screenWidth / 2 + tolerance), -1, screenYPosition])
+  |> translate(translate = [
+       -(screenWidth / 2 + tolerance),
+       -1,
+       screenYPosition
+     ])
 button()
-  |> translate(translate = [-(screenWidth / 2 + tolerance), -1, screenYPosition - buttonHeight - tolerance*2])
+  |> translate(translate = [
+       -(screenWidth / 2 + tolerance),
+       -1,
+       screenYPosition - buttonHeight - (tolerance * 2)
+     ])
 button()
-  |> rotate(%, roll = 0, pitch = 180, yaw = 0)
-  |> translate(translate = [screenWidth / 2 + tolerance, -1, screenYPosition - buttonHeight], global = true)
+  |> rotate(
+       %,
+       roll = 0,
+       pitch = 180,
+       yaw = 0,
+     )
+  |> translate(
+       translate = [
+         screenWidth / 2 + tolerance,
+         -1,
+         screenYPosition - buttonHeight
+       ],
+       global = true,
+     )
 button()
-  |> rotate(%, roll = 0, pitch = 180, yaw = 0)
-  |> translate(translate = [screenWidth / 2 + tolerance, -1, screenYPosition - buttonHeight*2 - tolerance * 2], global = true)
+  |> rotate(
+       %,
+       roll = 0,
+       pitch = 180,
+       yaw = 0,
+     )
+  |> translate(
+       translate = [
+         screenWidth / 2 + tolerance,
+         -1,
+         screenYPosition - (buttonHeight * 2) - (tolerance * 2)
+       ],
+       global = true,
+     )
--- a/public/kcl-samples/walkie-talkie/talk-button.kcl
+++ b/public/kcl-samples/walkie-talkie/talk-button.kcl
@ -1,6 +1,5 @@
 // Walkie talkie talk button

-
 // set units
@settings(defaultLengthUnit = in)

@ -8,9 +7,8 @@
 import width, thickness, talkButtonSideLength, talkButtonHeight from "globals.kcl"

 export fn talkButton() {
-
  // create the talk button sketch
-  talkButtonSketch = startSketchOn('YZ')
+  talkButtonSketch = startSketchOn(YZ)
    |> startProfileAt([
         -talkButtonSideLength / 2,
         talkButtonSideLength / 2
@ -23,14 +21,14 @@ export fn talkButton() {
  // create the talk button and apply fillets
  talkButton = extrude(talkButtonSketch, length = talkButtonHeight)
    |> fillet(
-      radius = 0.050,
-      tags = [
-        getNextAdjacentEdge(tag1),
-        getNextAdjacentEdge(tag2),
-        getNextAdjacentEdge(tag3),
-        getNextAdjacentEdge(tag4)
-      ]
-    )
+         radius = 0.050,
+         tags = [
+           getNextAdjacentEdge(tag1),
+           getNextAdjacentEdge(tag2),
+           getNextAdjacentEdge(tag3),
+           getNextAdjacentEdge(tag4)
+         ],
+       )
    |> appearance(color = '#D0FF01', metalness = 90, roughness = 90)

  return talkButton
--- a/public/kcl-samples/walkie-talkie/zoo-logo.kcl
+++ b/public/kcl-samples/walkie-talkie/zoo-logo.kcl
@ -80,4 +80,4 @@ export fn oLogo2(surface, origin, scale) {
       }, %)
    |> close()
  return oSketch002
-}
+}
--- a/public/kcl-samples/washer/main.kcl
+++ b/public/kcl-samples/washer/main.kcl
@ -14,17 +14,11 @@ thicknessMin = 0.024
 fn washer(plane, innerDia, outerDia, thk) {
  // Define the sketch of the washer
  washerSketch = startSketchOn(plane)
-    |> circle(
-         center = [0, 0],
-         radius = outerDia / 2
-       )
-    |> hole(circle(
-         center = [0, 0],
-         radius = innerDia / 2
-       ), %)
+    |> circle(center = [0, 0], radius = outerDia / 2)
+    |> hole(circle(center = [0, 0], radius = innerDia / 2), %)

  washer = extrude(washerSketch, length = thk)
  return washer
 }

-washer('XY', innerDiameter, outerDiameter, thicknessMax)
+washer(XY, innerDiameter, outerDiameter, thicknessMax)
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@ -1780,7 +1780,7 @@ dependencies = [

 [[package]]
 name = "kcl-bumper"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "anyhow",
 "clap",
@ -1791,7 +1791,7 @@ dependencies = [

 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "Inflector",
 "anyhow",
@ -1810,7 +1810,7 @@ dependencies = [

 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "proc-macro2",
 "quote",
@ -1819,7 +1819,7 @@ dependencies = [

 [[package]]
 name = "kcl-language-server"
-version = "0.2.54"
+version = "0.2.55"
 dependencies = [
 "anyhow",
 "clap",
@ -1840,7 +1840,7 @@ dependencies = [

 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "anyhow",
 "clap",
@ -1860,7 +1860,7 @@ dependencies = [

 [[package]]
 name = "kcl-lib"
-version = "0.2.54"
+version = "0.2.55"
 dependencies = [
 "anyhow",
 "approx 0.5.1",
@ -1928,7 +1928,7 @@ dependencies = [

 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.54"
+version = "0.3.55"
 dependencies = [
 "anyhow",
 "kcl-lib",
@ -1943,7 +1943,7 @@ dependencies = [

 [[package]]
 name = "kcl-test-server"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "anyhow",
 "hyper 0.14.32",
@ -1956,7 +1956,7 @@ dependencies = [

 [[package]]
 name = "kcl-to-core"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "anyhow",
 "async-trait",
@ -1970,7 +1970,7 @@ dependencies = [

 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.54"
+version = "0.1.55"
 dependencies = [
 "bson",
 "console_error_panic_hook",
--- a/rust/kcl-bumper/Cargo.toml
+++ b/rust/kcl-bumper/Cargo.toml
@ -1,7 +1,7 @@

 [package]
 name = "kcl-bumper"
-version = "0.1.54"
+version = "0.1.55"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-api"
 rust-version = "1.76"
--- a/rust/kcl-derive-docs/Cargo.toml
+++ b/rust/kcl-derive-docs/Cargo.toml
@ -1,7 +1,7 @@
 [package]
 name = "kcl-derive-docs"
 description = "A tool for generating documentation from Rust derive macros"
-version = "0.1.54"
+version = "0.1.55"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
--- a/rust/kcl-directory-test-macro/Cargo.toml
+++ b/rust/kcl-directory-test-macro/Cargo.toml
@ -1,7 +1,7 @@
 [package]
 name = "kcl-directory-test-macro"
 description = "A tool for generating tests from a directory of kcl files"
-version = "0.1.54"
+version = "0.1.55"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
--- a/rust/kcl-language-server-release/Cargo.toml
+++ b/rust/kcl-language-server-release/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "kcl-language-server-release"
-version = "0.1.54"
+version = "0.1.55"
 edition = "2021"
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
 publish = false
--- a/rust/kcl-language-server/Cargo.toml
+++ b/rust/kcl-language-server/Cargo.toml
@ -2,7 +2,7 @@
 name = "kcl-language-server"
 description = "A language server for KCL."
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
-version = "0.2.54"
+version = "0.2.55"
 edition = "2021"
 license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
--- a/rust/kcl-lib/Cargo.toml
+++ b/rust/kcl-lib/Cargo.toml
@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.54"
+version = "0.2.55"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
--- a/rust/kcl-lib/src/docs/mod.rs
+++ b/rust/kcl-lib/src/docs/mod.rs
@ -927,9 +927,8 @@ fn get_autocomplete_string_from_schema(schema: &schemars::schema::Schema) -> Res
 mod tests {
    use pretty_assertions::assert_eq;

-    use crate::docs::kcl_doc::{self, DocData};
-
    use super::StdLibFn;
+    use crate::docs::kcl_doc::{self, DocData};

    #[test]
    fn test_serialize_function() {
--- a/rust/kcl-lib/src/execution/exec_ast.rs
+++ b/rust/kcl-lib/src/execution/exec_ast.rs
@ -3,6 +3,7 @@ use std::collections::HashMap;
 use async_recursion::async_recursion;
 use indexmap::IndexMap;

+use super::kcl_value::TypeDef;
 use crate::{
    engine::ExecutionKind,
    errors::{KclError, KclErrorDetails},
@ -31,8 +32,6 @@ use crate::{
    CompilationError,
 };

-use super::kcl_value::TypeDef;
-
 enum StatementKind<'a> {
    Declaration { name: &'a str },
    Expression,
@ -59,7 +58,9 @@ impl ExecutorContext {
        for annotation in annotations {
            if annotation.name() == Some(annotations::SETTINGS) {
                if matches!(body_type, BodyType::Root) {
-                    exec_state.mod_local.settings.update_from_annotation(annotation)?;
+                    if exec_state.mod_local.settings.update_from_annotation(annotation)? {
+                        exec_state.mod_local.explicit_length_units = true;
+                    }
                    let new_units = exec_state.length_unit();
                    if !self.engine.execution_kind().await.is_isolated() {
                        self.engine
@ -299,7 +300,7 @@ impl ExecutorContext {
                    let impl_kind = annotations::get_impl(&ty.outer_attrs, metadata.source_range)?.unwrap_or_default();
                    match impl_kind {
                        annotations::Impl::Rust => {
-                            let std_path = match &exec_state.mod_local.settings.std_path {
+                            let std_path = match &exec_state.mod_local.std_path {
                                Some(p) => p,
                                None => {
                                    return Err(KclError::Semantic(KclErrorDetails {
@ -585,7 +586,7 @@ impl ExecutorContext {
    ) -> Result<KclValue, KclError> {
        let item = match init {
            Expr::None(none) => KclValue::from(none),
-            Expr::Literal(literal) => KclValue::from_literal((**literal).clone(), &exec_state.mod_local.settings),
+            Expr::Literal(literal) => KclValue::from_literal((**literal).clone(), exec_state),
            Expr::TagDeclarator(tag) => tag.execute(exec_state).await?,
            Expr::Name(name) => {
                let value = name.get_result(exec_state, self).await?.clone();
@ -616,7 +617,7 @@ impl ExecutorContext {
                    .unwrap_or(false);

                if rust_impl {
-                    if let Some(std_path) = &exec_state.mod_local.settings.std_path {
+                    if let Some(std_path) = &exec_state.mod_local.std_path {
                        let (func, props) = crate::std::std_fn(std_path, statement_kind.expect_name());
                        KclValue::Function {
                            value: FunctionSource::Std {
@ -719,10 +720,7 @@ impl BinaryPart {
    #[async_recursion]
    pub async fn get_result(&self, exec_state: &mut ExecState, ctx: &ExecutorContext) -> Result<KclValue, KclError> {
        match self {
-            BinaryPart::Literal(literal) => Ok(KclValue::from_literal(
-                (**literal).clone(),
-                &exec_state.mod_local.settings,
-            )),
+            BinaryPart::Literal(literal) => Ok(KclValue::from_literal((**literal).clone(), exec_state)),
            BinaryPart::Name(name) => name.get_result(exec_state, ctx).await.cloned(),
            BinaryPart::BinaryExpression(binary_expression) => binary_expression.get_result(exec_state, ctx).await,
            BinaryPart::CallExpression(call_expression) => call_expression.execute(exec_state, ctx).await,
@ -1854,15 +1852,12 @@ fn assign_args_to_params(
        return Err(err_wrong_number_args);
    }

-    let mem = &mut exec_state.mod_local.stack;
-    let settings = &exec_state.mod_local.settings;
-
    // Add the arguments to the memory.  A new call frame should have already
    // been created.
    for (index, param) in function_expression.params.iter().enumerate() {
        if let Some(arg) = args.get(index) {
            // Argument was provided.
-            mem.add(
+            exec_state.mut_stack().add(
                param.identifier.name.clone(),
                arg.value.clone(),
                (&param.identifier).into(),
@ -1872,11 +1867,10 @@ fn assign_args_to_params(
            if let Some(ref default_val) = param.default_value {
                // If the corresponding parameter is optional,
                // then it's fine, the user doesn't need to supply it.
-                mem.add(
-                    param.identifier.name.clone(),
-                    KclValue::from_default_param(default_val.clone(), settings),
-                    (&param.identifier).into(),
-                )?;
+                let value = KclValue::from_default_param(default_val.clone(), exec_state);
+                exec_state
+                    .mut_stack()
+                    .add(param.identifier.name.clone(), value, (&param.identifier).into())?;
            } else {
                // But if the corresponding parameter was required,
                // then the user has called with too few arguments.
@ -1916,8 +1910,6 @@ fn assign_args_to_params_kw(
    // Add the arguments to the memory.  A new call frame should have already
    // been created.
    let source_ranges = vec![function_expression.into()];
-    let mem = &mut exec_state.mod_local.stack;
-    let settings = &exec_state.mod_local.settings;

    for param in function_expression.params.iter() {
        if param.labeled {
@ -1925,7 +1917,7 @@ fn assign_args_to_params_kw(
            let arg_val = match arg {
                Some(arg) => arg.value.clone(),
                None => match param.default_value {
-                    Some(ref default_val) => KclValue::from_default_param(default_val.clone(), settings),
+                    Some(ref default_val) => KclValue::from_default_param(default_val.clone(), exec_state),
                    None => {
                        return Err(KclError::Semantic(KclErrorDetails {
                            source_ranges,
@ -1937,7 +1929,9 @@ fn assign_args_to_params_kw(
                    }
                },
            };
-            mem.add(param.identifier.name.clone(), arg_val, (&param.identifier).into())?;
+            exec_state
+                .mut_stack()
+                .add(param.identifier.name.clone(), arg_val, (&param.identifier).into())?;
        } else {
            let Some(unlabeled) = args.unlabeled.take() else {
                let param_name = &param.identifier.name;
@ -1954,7 +1948,7 @@ fn assign_args_to_params_kw(
                    })
                });
            };
-            mem.add(
+            exec_state.mut_stack().add(
                param.identifier.name.clone(),
                unlabeled.value.clone(),
                (&param.identifier).into(),
--- a/rust/kcl-lib/src/execution/kcl_value.rs
+++ b/rust/kcl-lib/src/execution/kcl_value.rs
@ -4,10 +4,11 @@ use anyhow::Result;
 use schemars::JsonSchema;
 use serde::Serialize;

-use super::{memory::EnvironmentRef, MetaSettings};
+use super::{types::UnitLen, EnvironmentRef, ExecState, MetaSettings};
 use crate::{
    errors::KclErrorDetails,
    execution::{
+        annotations::{SETTINGS, SETTINGS_UNIT_LENGTH},
        types::{NumericType, PrimitiveType, RuntimeType},
        Face, Helix, ImportedGeometry, Metadata, Plane, Sketch, Solid, TagIdentifier,
    },
@ -15,7 +16,7 @@ use crate::{
        DefaultParamVal, FunctionExpression, KclNone, Literal, LiteralValue, Node, TagDeclarator, TagNode,
    },
    std::StdFnProps,
-    KclError, ModuleId, SourceRange,
+    CompilationError, KclError, ModuleId, SourceRange,
 };

 pub type KclObjectFields = HashMap<String, KclValue>;
@ -308,22 +309,38 @@ impl KclValue {
        }
    }

-    pub(crate) fn from_literal(literal: Node<Literal>, settings: &MetaSettings) -> Self {
+    pub(crate) fn from_literal(literal: Node<Literal>, exec_state: &mut ExecState) -> Self {
        let meta = vec![literal.metadata()];
        match literal.inner.value {
-            LiteralValue::Number { value, suffix } => KclValue::Number {
-                value,
-                meta,
-                ty: NumericType::from_parsed(suffix, settings),
-            },
+            LiteralValue::Number { value, suffix } => {
+                let ty = NumericType::from_parsed(suffix, &exec_state.mod_local.settings);
+                if let NumericType::Default { len, .. } = &ty {
+                    if !exec_state.mod_local.explicit_length_units && *len != UnitLen::Mm {
+                        exec_state.warn(
+                            CompilationError::err(
+                                literal.as_source_range(),
+                                "Project-wide units are deprecated. Prefer to use per-file default units.",
+                            )
+                            .with_suggestion(
+                                "Fix by adding per-file settings",
+                                format!("@{SETTINGS}({SETTINGS_UNIT_LENGTH} = {len})\n"),
+                                // Insert at the start of the file.
+                                Some(SourceRange::new(0, 0, literal.module_id)),
+                                crate::errors::Tag::Deprecated,
+                            ),
+                        );
+                    }
+                }
+                KclValue::Number { value, meta, ty }
+            }
            LiteralValue::String(value) => KclValue::String { value, meta },
            LiteralValue::Bool(value) => KclValue::Bool { value, meta },
        }
    }

-    pub(crate) fn from_default_param(param: DefaultParamVal, settings: &MetaSettings) -> Self {
+    pub(crate) fn from_default_param(param: DefaultParamVal, exec_state: &mut ExecState) -> Self {
        match param {
-            DefaultParamVal::Literal(lit) => Self::from_literal(lit, settings),
+            DefaultParamVal::Literal(lit) => Self::from_literal(lit, exec_state),
            DefaultParamVal::KclNone(none) => KclValue::KclNone {
                value: none,
                meta: Default::default(),
--- a/rust/kcl-lib/src/execution/mod.rs
+++ b/rust/kcl-lib/src/execution/mod.rs
@ -992,7 +992,11 @@ mod tests {
    use pretty_assertions::assert_eq;

    use super::*;
-    use crate::{errors::KclErrorDetails, execution::memory::Stack, ModuleId};
+    use crate::{
+        errors::{KclErrorDetails, Severity},
+        execution::memory::Stack,
+        ModuleId,
+    };

    /// Convenience function to get a JSON value from memory and unwrap.
    #[track_caller]
@ -1595,6 +1599,34 @@ const inInches = 2.0 * inch()"#;
        );
    }

+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_unit_suggest() {
+        let src = "foo = 42";
+        let program = crate::Program::parse_no_errs(src).unwrap();
+        let ctx = ExecutorContext {
+            engine: Arc::new(Box::new(
+                crate::engine::conn_mock::EngineConnection::new().await.unwrap(),
+            )),
+            fs: Arc::new(crate::fs::FileManager::new()),
+            stdlib: Arc::new(crate::std::StdLib::new()),
+            settings: ExecutorSettings {
+                units: UnitLength::Ft,
+                ..Default::default()
+            },
+            context_type: ContextType::Mock,
+        };
+        let mut exec_state = ExecState::new(&ctx);
+        ctx.run(&program, &mut exec_state).await.unwrap();
+        let errs = exec_state.errors();
+        assert_eq!(errs.len(), 1, "{errs:?}");
+        let warn = &errs[0];
+        assert_eq!(warn.severity, Severity::Warning);
+        assert_eq!(
+            warn.apply_suggestion(src).unwrap(),
+            "@settings(defaultLengthUnit = ft)\nfoo = 42"
+        )
+    }
+
    #[tokio::test(flavor = "multi_thread")]
    async fn test_zero_param_fn() {
        let ast = r#"const sigmaAllow = 35000 // psi
--- a/rust/kcl-lib/src/execution/state.rs
+++ b/rust/kcl-lib/src/execution/state.rs
@ -72,6 +72,8 @@ pub(super) struct ModuleState {
    pub module_exports: Vec<String>,
    /// Settings specified from annotations.
    pub settings: MetaSettings,
+    pub(super) explicit_length_units: bool,
+    pub(super) std_path: Option<String>,
 }

 impl ExecState {
@ -296,10 +298,11 @@ impl ModuleState {
            stack: memory.new_stack(),
            pipe_value: Default::default(),
            module_exports: Default::default(),
+            explicit_length_units: false,
+            std_path,
            settings: MetaSettings {
                default_length_units: exec_settings.units.into(),
                default_angle_units: Default::default(),
-                std_path,
            },
        }
    }
@ -311,22 +314,23 @@ impl ModuleState {
 pub struct MetaSettings {
    pub default_length_units: types::UnitLen,
    pub default_angle_units: types::UnitAngle,
-    pub std_path: Option<String>,
 }

 impl MetaSettings {
    pub(crate) fn update_from_annotation(
        &mut self,
        annotation: &crate::parsing::ast::types::Node<Annotation>,
-    ) -> Result<(), KclError> {
+    ) -> Result<bool, KclError> {
        let properties = annotations::expect_properties(annotations::SETTINGS, annotation)?;

+        let mut updated_len = false;
        for p in properties {
            match &*p.inner.key.name {
                annotations::SETTINGS_UNIT_LENGTH => {
                    let value = annotations::expect_ident(&p.inner.value)?;
                    let value = types::UnitLen::from_str(value, annotation.as_source_range())?;
                    self.default_length_units = value;
+                    updated_len = true;
                }
                annotations::SETTINGS_UNIT_ANGLE => {
                    let value = annotations::expect_ident(&p.inner.value)?;
@ -346,6 +350,6 @@ impl MetaSettings {
            }
        }

-        Ok(())
+        Ok(updated_len)
    }
 }
--- a/rust/kcl-lib/src/log.rs
+++ b/rust/kcl-lib/src/log.rs
@ -6,8 +6,13 @@ use dhat::{HeapStats, Profiler};
 use web_time::Instant;

 const LOG_ENV_VAR: &str = "ZOO_LOG";
+const FORCE_LOGGING: bool = false;
+
 lazy_static::lazy_static! {
    static ref ENABLED: bool = {
+        if FORCE_LOGGING {
+            return true;
+        }
        let env_var = env::var(LOG_ENV_VAR);
        let Ok(env_var) = env_var else {
            return false;
--- a/rust/kcl-lib/src/parsing/ast/types/mod.rs
+++ b/rust/kcl-lib/src/parsing/ast/types/mod.rs
@ -1270,7 +1270,7 @@ pub enum NonCodeValue {
    /// An example of this is the following:
    /// ```no_run
    /// /* This is a
-    ///     block comment */
+    /// block comment */
    /// 1 + 1
    /// ```
    /// Now this is important. The block comment is attached to the next line.
--- a/rust/kcl-lib/src/settings/types/project.rs
+++ b/rust/kcl-lib/src/settings/types/project.rs
@ -158,13 +158,13 @@ fn named_view_point_version_one() -> f64 {
 #[ts(export)]
 pub struct NamedView {
    /// User defined name to identify the named view. A label.
-    #[serde(default, alias = "name", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "name")]
    pub name: String,
    /// Engine camera eye off set
-    #[serde(default, alias = "eyeOffset", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "eyeOffset")]
    pub eye_offset: f64,
    /// Engine camera vertical FOV
-    #[serde(default, alias = "fovY", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "fovY")]
    pub fov_y: f64,
    // Engine camera is orthographic or perspective projection
    #[serde(default, alias = "isOrtho")]
@ -173,16 +173,16 @@ pub struct NamedView {
    #[serde(default, alias = "orthoScaleEnabled")]
    pub ortho_scale_enabled: bool,
    /// Engine camera orthographic scaling factor
-    #[serde(default, alias = "orthoScaleFactor", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "orthoScaleFactor")]
    pub ortho_scale_factor: f64,
    /// Engine camera position that the camera pivots around
-    #[serde(default, alias = "pivotPosition", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "pivotPosition")]
    pub pivot_position: [f64; 3],
    /// Engine camera orientation in relation to the pivot position
-    #[serde(default, alias = "pivotRotation", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "pivotRotation")]
    pub pivot_rotation: [f64; 4],
    /// Engine camera world coordinate system orientation
-    #[serde(default, alias = "worldCoordSystem", skip_serializing_if = "is_default")]
+    #[serde(default, alias = "worldCoordSystem")]
    pub world_coord_system: String,
    /// Version number of the view point if the engine camera API changes
    #[serde(default = "named_view_point_version_one")]
--- a/rust/kcl-lib/src/std/sweep.rs
+++ b/rust/kcl-lib/src/std/sweep.rs
@ -151,7 +151,6 @@ pub async fn sweep(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 ///
 /// sweep(circleSketch, path = sweepPath, sectional = true)
 /// ```
-///

 #[stdlib {
    name = "sweep",
--- a/rust/kcl-lib/std/math.kcl
+++ b/rust/kcl-lib/std/math.kcl
@ -1,4 +1,5 @@
@no_std
+@settings(defaultLengthUnit = mm)

 /// The value of `pi`, Archimedes’ constant (π).
 ///
--- a/rust/kcl-lib/std/prelude.kcl
+++ b/rust/kcl-lib/std/prelude.kcl
@ -1,4 +1,5 @@
@no_std
+@settings(defaultLengthUnit = mm)

 // Note that everything in the prelude is treated as exported.

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Jonathan Tran	4b2c745db5	Fix error: unknown sketch function circle (#6012 )	2025-03-26 14:04:59 -04:00
Kevin Nadro	bb983021b1	Feature: Traditional menu actions in desktop application (#5892 ) * chore: skeleton for building and creating menus. Need electron to renderer interface to dynamically set the menu * chore: skeleton typing for communication between nodes and web side * chore: more skeleton for the different roles within the menu options, need more type safety * chore: adding more skeleton and templates of what the menus could be * chore: implemented first pass for helpRole links * fix: syntax issue stopped the build step * feature: loading different menus based on your page * feature: Home page file role implemented * chore: handling the build workflow for the signin page * fix: moving edit actionst to the edit menu * chore: adding preferences to the file role * chore: redoing help roles based on the question mark widget * fix: auto fmt * chore: examples of accelerator strings for Menu.MenuItems keyboard shortcuts! * chore: oddly specific toggle API for disabling MenuItems from JS. No rules! * fix: do not implement a custom label disable thingy, use id on menu and use the native APIga * fix: auto fmt * fix: adding some typechecks and auto fmt fixes * fix: trying to fix custom type? * fix: nvm we back, the lsp on my editor borked for a second * fix: adding one more level to the custom type for the labels * chore: cleaning up type definitions to read easier * fix: resolving yarn lint errors * chore: adding file sign out * chore: adding more file bar actions * chore: ready for PR draft * fix: preemptive GC collectoin bug fix if somehow a user interacts with a menu while it is being GCed * fix: linking the OG source * fix: set application menu to null to avoid default electron menu * chore: trying to add more typescript * chore: BIG workflow changes... better typing, less IPC junk * fix: remapping the icp functions to the cb option select... * chore: all og events are rehooked up with new workflow pattern * feat: adding more options to the native bar! * fix: todo * chore: cleaning up some menus and adding more * fix: desktop vs browser and lint errors * fix: typescript did not like sample electorn JS code for the basic templates with isMac conditionals... * fix: PR clean up * fix: more PR cleanup * A snapshot a day keeps the bugs away! 📷🐛 * fix: added the new help menu to the default sign in and modeling page * fix: disabled two menu actions within sign in page since they will not do anything. * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: mergining main, auto fixes * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: fixed ipc renderer off/remove listener bug * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * fix: report a bug to refresha and report a bug * fix: new type for webContents send payload that does not brick TS * fix: removing import file from url since it is not working in the command palette for manual user input * fix: removing old comment * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * chore: adding some E2E tests. * chore: added E2E tests for each file menu * fix: auto fixes * chore: adding more edit role E2E tests * chore: e2e test * chore: adding help role e2e test * A snapshot a day keeps the bugs away! 📷🐛 * chore: e2e test for all the menu options you can interact with in the frontend --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2025-03-26 13:03:44 -05:00
Jace Browning	d27b8871bc	Set bot user info to amend commits (#6011 )	2025-03-26 17:12:20 +00:00
Kevin Nadro	1753047d87	Feature: Release named views to all users (#5814 ) * chore: cleanup to get named views released! * fix: fixed gizmo, client side camera sync and remove DEV flag * yarp * chore: implementing E2E tests for creating a named view * fix: cleaning up and commenting E2E tests for named views * fix: we did it bois, the skip ceral i zation bricked my E2E test :( * fix: auto formatter * fix: snapshot uuid matching because rust will randomly generate thme * fix: auto fmt * fix: trying to resolve typescript issues * fix: handling NamedView vs CameraViewState type checking * fix: no idea I just mapped export to 3d export because we have no 2d export yet... * fix: random file I wrote because my editor was too slow * fix: git merge did not do what I wanted * A snapshot a day keeps the bugs away! 📷🐛 * fix: linter errors * A snapshot a day keeps the bugs away! 📷🐛 --------- Co-authored-by: 49fl <ircsurfer33@gmail.com> Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com> Co-authored-by: Pierre Jacquier <pierre@zoo.dev>	2025-03-26 16:12:35 +00:00
Josh Gomez	fa16fcedff	update all kcl-samples w/ format (#5999 )	2025-03-26 11:53:34 -04:00
Jonathan Tran	0677474097	Bump KCL in prep for release (#6010 )	2025-03-26 15:52:32 +00:00
Jace Browning	0c4826cdd5	Prevent overwriting the commit status on main (#6009 )	2025-03-26 10:41:41 -04:00
Pierre Jacquier	b6fe660b84	Add edit flow for point-and-click Chamfer and Fillet (#5946 ) * WIP: Add edit flow for Fillet Fixes #5521 * Support sweepedge fillet and add edit tests * A snapshot a day keeps the bugs away! 📷🐛 * Lint and cleanup * Add edit flow for Chamfer Fixes #5950 * Change to shared prepareToEdit function * Clean up * Lint * Clean up of types and use of getEdgeCutConsumedCodeRef * Find pipeIndex instead of hardcode * Add error for non-pipe fillet and test it * A snapshot a day keeps the bugs away! 📷🐛 * Fix lint * A snapshot a day keeps the bugs away! 📷🐛 * Utility function to reduce code reuse across fillet and chamfer * Clean up test diff * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * Lint * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * Remove change not needed * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * Fix typo in toast * A snapshot a day keeps the bugs away! 📷🐛 * A snapshot a day keeps the bugs away! 📷🐛 * Remove ['segment', 'sweepEdge'] const as it was causing some sort of circ dep --------- Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>	2025-03-26 11:57:08 +00:00
Jonathan Tran	c53fa421ad	Give a warning when using per-project default units (#5956 ) * Give a warning when using per-project default units Signed-off-by: Nick Cameron <nrc@ncameron.org> * Factor non-settings out of MetaSettings Signed-off-by: Nick Cameron <nrc@ncameron.org> * Fix formatting * Fix code pane e2e test * Fix callstack blowup in edit flow * Avoid dumb timeout issue with command registration in test * Use a safer way to wait for modeling command registration in test --------- Signed-off-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: Nick Cameron <nrc@ncameron.org> Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com> Co-authored-by: Pierre Jacquier <pierre@zoo.dev> Co-authored-by: Frank Noirot <frankjohnson1993@gmail.com>	2025-03-26 18:59:43 +13:00