Release KCL 77 (#7188)

Closes https://github.com/KittyCAD/modeling-app/issues/6805. Enables users to programatically construct colors, which will be helpful for 

- Applying color to visualize program execution and help debugging
- Doing weird cool shit

.github/workflows/cargo-test.yml

@@ -1,16 +1,22 @@
+name: cargo test
+
 on:
   push:
     branches:
       - main
   pull_request:
   workflow_dispatch:
+  schedule:
+    - cron: 0 * * * *  # hourly
+
 permissions:
   contents: read
   pull-requests: write
+
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
-name: cargo test
+
 jobs:
   build-test-artifacts:
     name: Build test artifacts
@@ -193,7 +199,7 @@ jobs:
           TAB_API_KEY: ${{ secrets.TAB_API_KEY }}
           CI_COMMIT_SHA: ${{ github.event.pull_request.head.sha }}
           CI_PR_NUMBER: ${{ github.event.pull_request.number }}
-          CI_SUITE: unit:kcl
+          CI_SUITE: e2e:kcl
   run-internal-kcl-samples:
     name: cargo test (internal-kcl-samples)
     runs-on:

.github/workflows/e2e-tests.yml

@@ -1,4 +1,5 @@
 name: E2E Tests
+
 on:
   push:
     branches:
@@ -156,7 +157,7 @@ jobs:
           TAB_API_KEY: ${{ secrets.TAB_API_KEY }}
           CI_COMMIT_SHA: ${{ github.event.pull_request.head.sha }}
           CI_PR_NUMBER: ${{ github.event.pull_request.number }}
-          CI_SUITE: snapshots
+          CI_SUITE: e2e:snapshots
           TARGET: web
 
       - name: Update snapshots
@@ -168,7 +169,7 @@ jobs:
           TAB_API_KEY: ${{ secrets.TAB_API_KEY }}
           CI_COMMIT_SHA: ${{ github.event.pull_request.head.sha }}
           CI_PR_NUMBER: ${{ github.event.pull_request.number }}
-          CI_SUITE: snapshots
+          CI_SUITE: e2e:snapshots
           TARGET: web
 
       - uses: actions/upload-artifact@v4
@@ -319,6 +320,7 @@ jobs:
           TAB_API_KEY: ${{ secrets.TAB_API_KEY }}
           CI_COMMIT_SHA: ${{ github.event.pull_request.head.sha }}
           CI_PR_NUMBER: ${{ github.event.pull_request.number }}
+          CI_SUITE: e2e:desktop
           TARGET: desktop
 
       - uses: actions/upload-artifact@v4

CONTRIBUTING.md

@@ -122,12 +122,11 @@ https://github.com/KittyCAD/modeling-app/issues/new
 
 #### 2. Push a new tag
 
-Create a new tag and push it to the repo. The `semantic-release.sh` script will automatically bump the minor part, which we use the most. For instance going from `v0.27.0` to `v0.28.0`.
+Decide on a `v`-prefixed semver `VERSION` (eg. `v1.2.3`) with the team and tag the repo, eg. on latest main:
 
 ```
-VERSION=$(./scripts/semantic-release.sh)
 git tag $VERSION
-git push origin --tags
+git push origin $VERSION
 ```
 
 This will trigger the `build-apps` workflow, set the version, build & sign the apps, and generate release files.

INSTALL.md

@@ -4,7 +4,7 @@ Compared to other CAD software, getting Zoo Design Studio up and running is quic
 
 ## Windows
 
-1. Download the [Zoo Design Studio installer](https://zoo.dev/modeling-app/download) for Windows and for your processor type.
+1. Download the [Zoo Design Studio installer](https://zoo.dev/design-studio/download) for Windows and for your processor type.
 
 2. Once downloaded, run the installer `Zoo Design Studio-{version}-{arch}-win.exe` which should take a few seconds.
 
@@ -12,16 +12,16 @@ Compared to other CAD software, getting Zoo Design Studio up and running is quic
 
 ## macOS
 
-1. Download the [Zoo Design Studio installer](https://zoo.dev/modeling-app/download) for macOS and for your processor type.
+1. Download the [Zoo Design Studio installer](https://zoo.dev/design-studio/download) for macOS and for your processor type.
 
 2. Once downloaded, open the disk image `Zoo Design Studio-{version}-{arch}-mac.dmg` and drag the applications to your `Applications` directory.
 
 3. You can then open your `Applications` directory and double-click on `Zoo Design Studio` to open.
 
 
-## Linux 
+## Linux
 
-1. Download the [Zoo Design Studio installer](https://zoo.dev/modeling-app/download) for Linux and for your processor type.
+1. Download the [Zoo Design Studio installer](https://zoo.dev/design-studio/download) for Linux and for your processor type.
 
 2. Install the dependencies needed to run the [AppImage format](https://appimage.org/).
     -  On Ubuntu, install the FUSE library with these commands in a terminal.
@@ -29,7 +29,7 @@ Compared to other CAD software, getting Zoo Design Studio up and running is quic
        sudo apt update
        sudo apt install libfuse2
        ```
-    - Optionally, follow [these steps](https://github.com/probonopd/go-appimage/blob/master/src/appimaged/README.md#initial-setup) to install `appimaged`. It is a daemon that makes interacting with AppImage files more seamless. 
+    - Optionally, follow [these steps](https://github.com/probonopd/go-appimage/blob/master/src/appimaged/README.md#initial-setup) to install `appimaged`. It is a daemon that makes interacting with AppImage files more seamless.
     - Once installed, copy the downloaded `Zoo Design Studio-{version}-{arch}-linux.AppImage` to the directory of your choice, for instance `~/Applications`.
 
    - `appimaged` should automatically find it and make it executable. If not, run:

README.md

@@ -2,7 +2,7 @@
 
 # Zoo Design Studio
 
-[zoo.dev/modeling-app](https://zoo.dev/modeling-app)
+[zoo.dev/design-studio](https://zoo.dev/design-studio)
 
 A CAD application from the future, brought to you by the [Zoo team](https://zoo.dev).
 
@@ -40,12 +40,8 @@ The 3D view in Design Studio is just a video stream from our hosted geometry eng
 
 ## Get Started
 
-We recommend downloading the latest application binary from our [releases](https://github.com/KittyCAD/modeling-app/releases) page. If you don't see your platform or architecture supported there, please file an issue.
+We recommend downloading the latest application binary from our [website](https://zoo.dev/design-studio/download). If you don't see your platform or architecture supported there, please file an issue. See the [installation guide](INSTALL.md) for additional instructions.
 
 ## Developing
 
-Finally, if you'd like to run a development build or contribute to the project, please visit our [contributor guide](CONTRIBUTING.md) to get started.
+Finally, if you'd like to run a development build or contribute to the project, please visit our [contributor guide](CONTRIBUTING.md) to get started. To contribute to the KittyCAD Language, see the dedicated [readme](rust/kcl-lib/README.md) for KCL.
-
-## KCL
-
-To contribute to the KittyCAD Language, see the [README](https://github.com/KittyCAD/modeling-app/tree/main/rust/kcl-lib) for KCL.

docs/kcl-std/index.md

@@ -16,6 +16,8 @@ layout: manual
   * [`helix`](/docs/kcl-std/functions/std-helix)
   * [`offsetPlane`](/docs/kcl-std/functions/std-offsetPlane)
   * [`patternLinear2d`](/docs/kcl-std/patternLinear2d)
+* [**std::appearance**](/docs/kcl-std/modules/std-appearance)
+  * [`appearance::hexString`](/docs/kcl-std/functions/std-appearance-hexString)
 * [**std::array**](/docs/kcl-std/modules/std-array)
   * [`map`](/docs/kcl-std/functions/std-array-map)
   * [`pop`](/docs/kcl-std/functions/std-array-pop)

docs/kcl-std/modules/std-appearance.md

@@ -0,0 +1,16 @@
+---
+title: "appearance"
+subtitle: "Module in std"
+excerpt: ""
+layout: manual
+---
+
+
+
+
+
+
+## Functions and constants
+
+* [`appearance::hexString`](/docs/kcl-std/functions/std-appearance-hexString)
+

docs/kcl-std/modules/std.md

@@ -15,6 +15,7 @@ You might also want the [KCL language reference](/docs/kcl-lang) or the [KCL gui
 
 ## Modules
 
+* [`appearance::appearance`](/docs/kcl-std/modules/std-appearance)
 * [`array`](/docs/kcl-std/modules/std-array)
 * [`math`](/docs/kcl-std/modules/std-math)
 * [`sketch`](/docs/kcl-std/modules/std-sketch)

docs/kcl-std/patternLinear3d.md

@@ -26,7 +26,7 @@ patternLinear3d(
 | `solids` | [`[Solid]`](/docs/kcl-std/types/std-types-Solid) | The solid(s) to duplicate | Yes |
 | `instances` | [`number`](/docs/kcl-std/types/std-types-number) | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `distance` | [`number`](/docs/kcl-std/types/std-types-number) | Distance between each repetition. Also known as 'spacing'. | Yes |
-| `axis` | [`Point3d`](/docs/kcl-std/types/std-types-Point3d) | The axis of the pattern. A 2D vector. | Yes |
+| `axis` | [`Point3d`](/docs/kcl-std/types/std-types-Point3d) | The axis of the pattern. A 3D vector. | Yes |
 | `useOriginal` | [`bool`](/docs/kcl-std/types/std-types-bool) | If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false. | No |
 
 ### Returns

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

@@ -78,11 +78,10 @@ extrude001 = extrude(sketch001, length = 5)`
 
     // Delete a character to break the KCL
     await editor.openPane()
-    await editor.scrollToText('bracketLeg1Sketch, length = thickness)')
+    await editor.scrollToText('extrude(%, length = width)')
-    await page
+    await page.getByText('extrude(%, length = width)').click()
-      .getByText('extrude(bracketLeg1Sketch, length = thickness)')
+
-      .click()
+    await page.keyboard.press(')')
-    await page.keyboard.press('Backspace')
 
     // Ensure that a badge appears on the button
     await expect(codePaneButtonHolder).toContainText('notification')
@@ -99,16 +98,11 @@ extrude001 = extrude(sketch001, length = 5)`
 
     await page.waitForTimeout(500)
 
-    // Ensure that a badge appears on the button
-    await expect(codePaneButtonHolder).toContainText('notification')
-    // Ensure we have no errors in the gutter.
-    await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
-
     // Open the code pane
     await editor.openPane()
 
-    // Go to our problematic code again (missing closing paren!)
+    // Go to our problematic code again
-    await editor.scrollToText('extrude(bracketLeg1Sketch, length = thickness')
+    await editor.scrollToText('extrude(%, length = w')
 
     // Ensure that a badge appears on the button
     await expect(codePaneButtonHolder).toContainText('notification')

e2e/playwright/editor-tests.spec.ts

@@ -1001,7 +1001,7 @@ a1 = startSketchOn(offsetPlane(XY, offset = 10))
       await expect(page.locator('.cm-content')).toHaveText(
         `@settings(defaultLengthUnit = in)
 sketch001 = startSketchOn(XZ)
-        |> startProfile(%, at = [3.14, 12])
+        |> startProfile(%, at = [0, 12])
         |> xLine(%, length = 5) // lin`.replaceAll('\n', '')
       )
 
@@ -1076,7 +1076,7 @@ sketch001 = startSketchOn(XZ)
       await expect(page.locator('.cm-content')).toHaveText(
         `@settings(defaultLengthUnit = in)
 sketch001 = startSketchOn(XZ)
-        |> startProfile(%, at = [3.14, 12])
+        |> startProfile(%, at = [0, 12])
         |> xLine(%, length = 5) // lin`.replaceAll('\n', '')
       )
     })
@@ -1590,4 +1590,38 @@ sketch001 = startSketchOn(XZ)
       await expect(page.getByTestId('center-rectangle')).toBeVisible()
     })
   })
+
+  test('syntax errors still show when reopening KCL pane', async ({
+    page,
+    homePage,
+    scene,
+    cmdBar,
+  }) => {
+    const u = await getUtils(page)
+    await page.setBodyDimensions({ width: 1200, height: 500 })
+
+    await homePage.goToModelingScene()
+
+    // Wait for connection, this is especially important for this test, because safeParse is invoked when
+    // connection is established which would interfere with the test if it happened during later steps.
+    await scene.connectionEstablished()
+    await scene.settled(cmdBar)
+
+    // Code with no error
+    await u.codeLocator.fill(`x = 7`)
+    await page.waitForTimeout(200) // allow some time for the error to show potentially
+    await expect(page.locator('.cm-lint-marker-error')).toHaveCount(0)
+
+    // Code with error
+    await u.codeLocator.fill(`x 7`)
+    await expect(page.locator('.cm-lint-marker-error')).toHaveCount(1)
+
+    // Close and reopen KCL code panel
+    await u.closeKclCodePanel()
+    await expect(page.locator('.cm-lint-marker-error')).toHaveCount(0) // error disappears on close
+    await u.openKclCodePanel()
+
+    // Verify error is still visible
+    await expect(page.locator('.cm-lint-marker-error')).toHaveCount(1)
+  })
 })

e2e/playwright/text-to-cad-tests.spec.ts

@@ -1,5 +1,3 @@
-import fs from 'fs'
-import { join } from 'path'
 import type { Page } from '@playwright/test'
 
 import { createProject, getUtils } from '@e2e/playwright/test-utils'
@@ -403,106 +401,6 @@ test.describe('Text-to-CAD tests', () => {
     await expect(page.getByText(promptWithNewline)).toBeVisible()
   })
 
-  // This will be fine once greg makes prompt at top of file deterministic
-  test('can do many at once and get many prompts back, and interact with many', async ({
-    page,
-    homePage,
-    cmdBar,
-  }) => {
-    // Let this test run longer since we've seen it timeout.
-    test.setTimeout(180_000)
-
-    const u = await getUtils(page)
-
-    await page.setBodyDimensions({ width: 1000, height: 500 })
-
-    await homePage.goToModelingScene()
-    await u.waitForPageLoad()
-
-    await sendPromptFromCommandBarAndSetExistingProject(
-      page,
-      'a 2x4 lego',
-      cmdBar
-    )
-
-    await sendPromptFromCommandBarAndSetExistingProject(
-      page,
-      'a 2x8 lego',
-      cmdBar
-    )
-
-    await sendPromptFromCommandBarAndSetExistingProject(
-      page,
-      'a 2x10 lego',
-      cmdBar
-    )
-
-    // Find the toast.
-    // Look out for the toast message
-    const submittingToastMessage = page.getByText(
-      `Submitting to Text-to-CAD API...`
-    )
-    await expect(submittingToastMessage.first()).toBeVisible()
-
-    const generatingToastMessage = page.getByText(
-      `Generating parametric model...`
-    )
-    await expect(generatingToastMessage.first()).toBeVisible({
-      timeout: 10_000,
-    })
-
-    const successToastMessage = page.getByText(`Text-to-CAD successful`)
-    // We should have three success toasts.
-    await expect(successToastMessage).toHaveCount(3, { timeout: 25_000 })
-
-    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
-    await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
-    await expect(page.getByText(`a 2x10 lego`)).toBeVisible()
-
-    // Ensure if you reject one, the others stay.
-    const rejectButton = page.getByRole('button', { name: 'Reject' })
-    await expect(rejectButton.first()).toBeVisible()
-    // Click the reject button on the first toast.
-    await rejectButton.first().click()
-
-    // The first toast should disappear, but not the others.
-    await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
-    await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
-    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
-
-    // Ensure you can copy the code for one of the models remaining.
-    const copyToClipboardButton = page.getByRole('button', {
-      name: 'Accept',
-    })
-    await expect(copyToClipboardButton.first()).toBeVisible()
-    // Click the button.
-    await copyToClipboardButton.first().click()
-
-    // Do NOT do AI tests like this: "Expect the code to be pasted."
-    // Reason: AI tests are NONDETERMINISTIC. Thus we need to be as most
-    // general as we can for the assertion.
-    // We can use Kolmogorov complexity as a measurement of the
-    // "probably most minimal version of this program" to have a lower
-    // bound to work with. It is completely by feel because there are
-    // no proofs that any program is its smallest self.
-    const code2x8 = await page.locator('.cm-content').innerText()
-    await expect(code2x8.length).toBeGreaterThan(249)
-
-    // Ensure the final toast remains.
-    await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
-    await expect(page.getByText(`Prompt: "a 2x8 lego`)).not.toBeVisible()
-    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
-
-    // Ensure you can copy the code for the final model.
-    await expect(copyToClipboardButton).toBeVisible()
-    // Click the button.
-    await copyToClipboardButton.click()
-
-    // Expect the code to be pasted.
-    const code2x4 = await page.locator('.cm-content').innerText()
-    await expect(code2x4.length).toBeGreaterThan(249)
-  })
-
   test('can do many at once with errors, clicking dismiss error does not dismiss all', async ({
     page,
     homePage,
@@ -675,82 +573,6 @@ async function sendPromptFromCommandBarAndSetExistingProject(
   })
 }
 
-test(
-  'Text-to-CAD functionality',
-  { tag: '@electron' },
-  async ({ context, page, cmdBar }, testInfo) => {
-    const projectName = 'project-000'
-    const prompt = 'lego 2x4'
-    const textToCadFileName = 'lego-2x4.kcl'
-
-    const { dir } = await context.folderSetupFn(async () => {})
-
-    const fileExists = () =>
-      fs.existsSync(join(dir, projectName, textToCadFileName))
-
-    const { openFilePanel, openKclCodePanel, waitForPageLoad } = await getUtils(
-      page,
-      test
-    )
-
-    await page.setBodyDimensions({ width: 1200, height: 500 })
-
-    // Locators
-    const projectMenuButton = page
-      .getByTestId('project-sidebar-toggle')
-      .filter({ hasText: projectName })
-    const textToCadFileButton = page.getByRole('listitem').filter({
-      has: page.getByRole('button', { name: textToCadFileName }),
-    })
-    const textToCadComment = page.getByText(
-      `// Generated by Text-to-CAD: ${prompt}`
-    )
-
-    // Create and navigate to the project
-    await createProject({ name: 'project-000', page })
-
-    // Wait for Start Sketch otherwise you will not have access Text-to-CAD command
-    await waitForPageLoad()
-    await openFilePanel()
-    await openKclCodePanel()
-
-    await test.step(`Test file creation`, async () => {
-      await sendPromptFromCommandBarAndSetExistingProject(
-        page,
-        prompt,
-        cmdBar,
-        projectName
-      )
-      // File is considered created if it shows up in the Project Files pane
-      await expect(textToCadFileButton).toBeVisible({ timeout: 20_000 })
-      expect(fileExists()).toBeTruthy()
-    })
-
-    await test.step(`Test file navigation`, async () => {
-      await expect(projectMenuButton).toContainText('main.kcl')
-      await textToCadFileButton.click()
-      // File can be navigated and loaded assuming a specific KCL comment is loaded into the KCL code pane
-      await expect(textToCadComment).toBeVisible({ timeout: 20_000 })
-      await expect(projectMenuButton).toContainText(textToCadFileName)
-    })
-
-    await test.step(`Test file deletion on rejection`, async () => {
-      const rejectButton = page.getByRole('button', { name: 'Reject' })
-      // A file is created and can be navigated to while this prompt is still opened
-      // Click the "Reject" button within the prompt and it will delete the file.
-      await rejectButton.click()
-
-      const submittingToastMessage = page.getByText(
-        `Successfully deleted file "lego-2x4.kcl"`
-      )
-      await expect(submittingToastMessage).toBeVisible()
-      expect(fileExists()).toBeFalsy()
-      // Confirm we've navigated back to the main.kcl file after deletion
-      await expect(projectMenuButton).toContainText('main.kcl')
-    })
-  }
-)
-
 /**
  * Below there are twelve (12) tests for testing the navigation and file creation
  * logic around text to cad. The Text to CAD command is now globally available

index.html

@@ -16,7 +16,6 @@
     <link rel="apple-touch-icon" href="/logo192.png" />
     <link rel="manifest" href="/manifest.json" />
     <link rel="stylesheet" href="./inter/inter.css" />
-    <link rel="stylesheet" href="https://use.typekit.net/zzv8rvm.css" />
     <script
       defer
       data-domain="app.zoo.dev"

package-lock.json

@@ -2492,6 +2492,7 @@
     },
     "node_modules/@clack/prompts/node_modules/is-unicode-supported": {
       "version": "1.3.0",
+      "extraneous": true,
       "inBundle": true,
       "license": "MIT",
       "engines": {

public/announce_release.py

@@ -27,7 +27,7 @@ if len(modified_release_body) > max_length:
 # Message to send to Discord
 data = {
     "content": textwrap.dedent(f'''
-        **{release_version}** is now available! Check out the latest features and improvements here: <https://zoo.dev/modeling-app/download>
+        **{release_version}** is now available! Check out the latest features and improvements here: <https://zoo.dev/design-studio>
 
         {modified_release_body}
     '''),

public/kcl-samples/README.md

@@ -143,10 +143,14 @@ When you submit a PR to add or modify KCL samples, images will be generated and
 [![spur-reduction-gearset](screenshots/spur-reduction-gearset.png)](spur-reduction-gearset/main.kcl)
 #### [surgical-drill-guide](surgical-drill-guide/main.kcl) ([screenshot](screenshots/surgical-drill-guide.png))
 [![surgical-drill-guide](screenshots/surgical-drill-guide.png)](surgical-drill-guide/main.kcl)
+#### [telemetry-antenna](telemetry-antenna/main.kcl) ([screenshot](screenshots/telemetry-antenna.png))
+[![telemetry-antenna](screenshots/telemetry-antenna.png)](telemetry-antenna/main.kcl)
 #### [thermal-block-insert](thermal-block-insert/main.kcl) ([screenshot](screenshots/thermal-block-insert.png))
 [![thermal-block-insert](screenshots/thermal-block-insert.png)](thermal-block-insert/main.kcl)
 #### [tooling-nest-block](tooling-nest-block/main.kcl) ([screenshot](screenshots/tooling-nest-block.png))
 [![tooling-nest-block](screenshots/tooling-nest-block.png)](tooling-nest-block/main.kcl)
+#### [truss-structure](truss-structure/main.kcl) ([screenshot](screenshots/truss-structure.png))
+[![truss-structure](screenshots/truss-structure.png)](truss-structure/main.kcl)
 #### [utility-sink](utility-sink/main.kcl) ([screenshot](screenshots/utility-sink.png))
 [![utility-sink](screenshots/utility-sink.png)](utility-sink/main.kcl)
 #### [walkie-talkie](walkie-talkie/main.kcl) ([screenshot](screenshots/walkie-talkie.png))

public/kcl-samples/brake-rotor/main.kcl

@@ -1,3 +1,4 @@
+// Brake Rotor
 // A 320mm vented brake disc (rotor), with straight vanes, 30mm thick. The disc bell should accommodate 5 M12 wheel studs on a 114.3mm pitch circle diameter.
 
 

public/kcl-samples/manifest.json

@@ -78,8 +78,8 @@
     "file": "main.kcl",
     "pathFromProjectDirectoryToFirstFile": "brake-rotor/main.kcl",
     "multipleFiles": false,
-    "title": "A 320mm vented brake disc (rotor), with straight vanes, 30mm thick. The disc bell should accommodate 5 M12 wheel studs on a 114.3mm pitch circle diameter.",
+    "title": "Brake Rotor",
-    "description": "",
+    "description": "A 320mm vented brake disc (rotor), with straight vanes, 30mm thick. The disc bell should accommodate 5 M12 wheel studs on a 114.3mm pitch circle diameter.",
     "files": [
       "main.kcl"
     ]
@@ -632,6 +632,16 @@
       "main.kcl"
     ]
   },
+  {
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "telemetry-antenna/main.kcl",
+    "multipleFiles": false,
+    "title": "Aircraft telemetry antenna plate",
+    "description": "Consists of a circular base plate 3 inches in diameter and 0.08 inches thick, with a tapered monopole antenna mounted at the top with a base diameter of 0.65 inches and height of 1.36 inches. Also consists of a mounting base and connector at the bottom of the plate. The plate also has 6 countersunk holes at a defined pitch circle diameter.",
+    "files": [
+      "main.kcl"
+    ]
+  },
   {
     "file": "main.kcl",
     "pathFromProjectDirectoryToFirstFile": "thermal-block-insert/main.kcl",
@@ -652,6 +662,16 @@
       "main.kcl"
     ]
   },
+  {
+    "file": "main.kcl",
+    "pathFromProjectDirectoryToFirstFile": "truss-structure/main.kcl",
+    "multipleFiles": false,
+    "title": "Truss Structure",
+    "description": "A truss structure is a framework composed of triangular units made from straight members connected at joints, often called nodes. Trusses are widely used in architecture, civil engineering, and construction for their ability to support large loads with minimal material.",
+    "files": [
+      "main.kcl"
+    ]
+  },
   {
     "file": "main.kcl",
     "pathFromProjectDirectoryToFirstFile": "utility-sink/main.kcl",

public/kcl-samples/telemetry-antenna/main.kcl

@@ -0,0 +1,63 @@
+// Aircraft telemetry antenna plate
+// Consists of a circular base plate 3 inches in diameter and 0.08 inches thick, with a tapered monopole antenna mounted at the top with a base diameter of 0.65 inches and height of 1.36 inches. Also consists of a mounting base and connector at the bottom of the plate. The plate also has 6 countersunk holes at a defined pitch circle diameter.
+
+// Set units
+@settings(defaultLengthUnit = in)
+
+// Define parameters
+plateThickness = 0.08
+plateDia = 3
+antennaBaseDia = 0.65
+antennaAngle = 95
+antennaHeight = 1.36
+seatingDia = 0.625
+totalHeight = 2.14
+
+boltDiameter = .196
+boltPitchCircleDiameter = 2.5
+
+// 2D cross-sectional profile of the part that will later be revolved
+antennaCrossSectionSketch = startSketchOn(YZ)
+antennaCrossSectionProfile = startProfile(antennaCrossSectionSketch, at = [plateDia / 2, 0])
+  |> yLine(length = plateThickness)
+  |> xLine(length = -(plateDia - antennaBaseDia) / 2, tag = $seg03)
+  |> angledLine(angle = antennaAngle, length = 1.1, tag = $seg01)
+  |> tangentialArc(endAbsolute = [0.025, antennaHeight])
+  |> xLine(endAbsolute = 0, tag = $seg02)
+  |> yLine(length = -totalHeight)
+  |> xLine(length = .25)
+  |> yLine(length = .05)
+  |> angledLine(angle = 45, length = 0.025)
+  |> yLine(length = .125)
+  |> angledLine(angle = 135, length = 0.025)
+  |> yLine(length = .125)
+  |> xLine(length = .025)
+  |> yLine(length = .025)
+  |> xLine(endAbsolute = seatingDia / 2)
+  |> yLine(endAbsolute = -0.25)
+  |> xLine(endAbsolute = 0.6)
+  |> yLine(endAbsolute = 0)
+  |> close()
+
+// Revolution about y-axis of earlier profile
+antennaCrossSectionRevolve = revolve(antennaCrossSectionProfile, angle = 360, axis = Y)
+
+// Function to create a countersunk hole
+fn countersink(@holePosition) {
+  startSketchOn(antennaCrossSectionRevolve, face = seg03)
+    |> circle(center = holePosition, radius = boltDiameter / 2, tag = $hole01)
+    |> extrude(length = -plateThickness)
+    |> chamfer(length = 0.04, tags = [hole01])
+  return {  }
+}
+
+// PCD converted to radius for positioning the holes
+r = boltPitchCircleDiameter / 2
+
+// 6 countersunk holes using the countersink function
+countersink([r, 0]) // 0 °
+countersink([r * 0.5, r * 0.8660254]) // 60 °
+countersink([-r * 0.5, r * 0.8660254]) // 120 °
+countersink([-r, 0]) // 180 °
+countersink([-r * 0.5, -r * 0.8660254]) // 240 °
+countersink([r * 0.5, -r * 0.8660254]) // 300 °

public/kcl-samples/truss-structure/main.kcl

@@ -0,0 +1,142 @@
+// Truss Structure
+// A truss structure is a framework composed of triangular units made from straight members connected at joints, often called nodes. Trusses are widely used in architecture, civil engineering, and construction for their ability to support large loads with minimal material.
+
+
+
+
+@settings(defaultLengthUnit = in)
+
+// Define parameters
+thickness = 4
+totalLength = 180
+totalWidth = 120
+totalHeight = 120
+legHeight = 48
+topTrussAngle = 25
+beamWidth = 4
+beamLength = 2
+sparAngle = 30
+nFrames = 3
+crossBeamLength = 82
+
+// Sketch the top frame
+topFrameSketch = startSketchOn(YZ)
+profile001 = startProfile(topFrameSketch, at = [totalWidth / 2, 0])
+  |> xLine(length = -totalWidth, tag = $bottomFace)
+  |> yLine(length = 12)
+  |> angledLine(angle = topTrussAngle, endAbsoluteX = 0, tag = $tag001)
+  |> angledLine(angle = -topTrussAngle, endAbsoluteX = totalWidth / 2, tag = $tag002)
+  |> close()
+
+// Create two holes in the top frame sketch to create the center beam
+profile002 = startProfile(topFrameSketch, at = [totalWidth / 2 - thickness, thickness])
+  |> xLine(endAbsolute = thickness / 2)
+  |> yLine(endAbsolute = segEndY(tag001) - thickness)
+  |> angledLine(endAbsoluteX = profileStartX(%), angle = -topTrussAngle)
+  |> close(%)
+
+profile003 = startProfile(topFrameSketch, at = [-totalWidth / 2 + thickness, thickness])
+  |> xLine(endAbsolute = -thickness / 2)
+  |> yLine(endAbsolute = segEndY(tag001) - thickness)
+  |> angledLine(endAbsoluteX = profileStartX(%), angle = 180 + topTrussAngle)
+  |> close(%)
+profile004 = subtract2d(profile001, tool = profile002)
+subtract2d(profile001, tool = profile003)
+
+// Extrude the sketch to make the top frame
+topFrame = extrude(profile001, length = beamLength)
+
+// Spar 1
+sketch002 = startSketchOn(offsetPlane(YZ, offset = .1))
+profile006 = startProfile(sketch002, at = [thickness / 2 - 1, 14])
+  |> angledLine(angle = sparAngle, length = 25)
+  |> angledLine(angle = -topTrussAngle, length = 5)
+  |> angledLine(angle = 180 + sparAngle, endAbsoluteX = profileStartX(%))
+  |> close(%)
+
+spar001 = extrude(profile006, length = 1.8)
+
+// Spar2
+profile007 = startProfile(sketch002, at = [-thickness / 2 + 1, 14])
+  |> angledLine(angle = 180 - sparAngle, length = 25)
+  |> angledLine(angle = 180 + topTrussAngle, length = 5)
+  |> angledLine(angle = -sparAngle, endAbsoluteX = profileStartX(%))
+  |> close(%)
+
+spar002 = extrude(profile007, length = 1.8)
+
+// Combine the top frame with the intermediate support beams
+newFrame = topFrame + spar001 + spar002
+
+// Create the two legs on the frame
+leg001Sketch = startSketchOn(offsetPlane(XY, offset = .1))
+legProfile001 = startProfile(leg001Sketch, at = [0, -totalWidth / 2])
+  |> xLine(%, length = beamLength - .1)
+  |> yLine(%, length = beamWidth - 1)
+  |> xLine(%, endAbsolute = profileStartX(%))
+  |> close(%)
+
+legProfile002 = startProfile(leg001Sketch, at = [0, totalWidth / 2])
+  |> xLine(%, length = beamLength - .1)
+  |> yLine(%, length = -(beamWidth - 1))
+  |> xLine(%, endAbsolute = profileStartX(%))
+  |> close(%)
+leg001 = extrude(legProfile001, length = -legHeight - .1)
+leg002 = extrude(legProfile002, length = -legHeight - .1)
+
+// Combine the top frame with the legs and pattern
+fullFrame = newFrame + leg001 + leg002
+  |> patternLinear3d(
+       %,
+       instances = nFrames,
+       distance = crossBeamLength + beamLength,
+       axis = [-1, 0, 0],
+     )
+
+// Create the center cross beam
+centerCrossBeamSketch = startSketchOn(YZ)
+profile005 = startProfile(centerCrossBeamSketch, at = [0, segEndY(tag001) - 1])
+  |> angledLine(%, angle = -topTrussAngle, length = beamWidth * 3 / 8)
+  |> yLine(length = -beamWidth * 3 / 8)
+  |> angledLine(%, angle = 180 - topTrussAngle, length = beamWidth * 3 / 8)
+  |> angledLine(%, angle = 180 + topTrussAngle, length = beamWidth * 3 / 8)
+  |> yLine(length = beamWidth * 3 / 8)
+  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
+  |> close()
+
+// Extrude the center cross beam and pattern to every frame
+centerCrossBeam = extrude(profile005, length = -crossBeamLength)
+  |> patternLinear3d(
+       %,
+       instances = nFrames - 1,
+       distance = crossBeamLength + beamLength,
+       axis = [-1, 0, 0],
+     )
+
+// Create the two side cross beams
+sideCrossBeamSketch = startSketchOn(-YZ)
+profile008 = startProfile(
+       sideCrossBeamSketch,
+       at = [
+         -totalWidth / 2 + 0.5,
+         segEndY(tag002) - .5
+       ],
+     )
+  |> yLine(length = -beamLength)
+  |> xLine(length = 3 / 4 * beamWidth)
+  |> yLine(length = beamLength)
+  |> close()
+profile009 = startProfile(sideCrossBeamSketch, at = [totalWidth / 2, segEndY(tag002) - .5])
+  |> yLine(length = -beamLength)
+  |> xLine(%, length = -3 / 4 * beamWidth)
+  |> yLine(%, length = beamLength)
+  |> close(%)
+
+// Extrude the side cross beams and pattern to every frame.
+extrude([profile008, profile009], length = crossBeamLength)
+  |> patternLinear3d(
+       %,
+       instances = nFrames - 1,
+       distance = crossBeamLength + beamLength,
+       axis = [-1, 0, 0],
+     )

rust/Cargo.lock

@@ -1815,7 +1815,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "anyhow",
  "clap",
@@ -1826,7 +1826,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "Inflector",
  "anyhow",
@@ -1845,7 +1845,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -1855,7 +1855,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "anyhow",
  "clap",
@@ -1876,7 +1876,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "anyhow",
  "clap",
@@ -1896,7 +1896,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.75"
+version = "0.2.77"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -1973,7 +1973,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.75"
+version = "0.3.77"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -1988,7 +1988,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -2001,7 +2001,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2015,7 +2015,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.75"
+version = "0.1.77"
 dependencies = [
  "anyhow",
  "bson",

rust/justfile

@@ -36,20 +36,20 @@ new-sim-test test_name render_to_png="true":
 
 # Run a KCL deterministic simulation test case and accept output.
 overwrite-sim-test-sample test_name:
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::parse_{{test_name}}
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::parse_{{test_name}}
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::unparse_{{test_name}}
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::unparse_{{test_name}}
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::kcl_test_execute_{{test_name}}
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::kcl_test_execute_{{test_name}}
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::test_after_engine
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::kcl_samples::test_after_engine
 
 overwrite-sim-test test_name:
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::parse
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::parse
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::unparse
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::unparse
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::kcl_test_execute
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::kcl_test_execute
-    [ {{test_name}} != "kcl_samples" ] || EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::test_after_engine
+    [ {{test_name}} != "kcl_samples" ] || ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests::{{test_name}}::test_after_engine
 
 # Regenerate all the simulation test output.
 redo-sim-tests:
-    EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests
+    ZOO_SIM_UPDATE=always EXPECTORATE=overwrite TWENTY_TWENTY=overwrite {{cita}} {{kcl_lib_flags}} --no-quiet -- simulation_tests
 
 test:
     cargo install cargo-nextest

rust/kcl-bumper/Cargo.toml

@@ -1,7 +1,7 @@
 
 [package]
 name = "kcl-bumper"
-version = "0.1.75"
+version = "0.1.77"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-api"
 rust-version = "1.76"

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.75"
+version = "0.1.77"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-derive-docs/src/example_tests.rs

@@ -0,0 +1,142 @@
+use proc_macro2::Span;
+use quote::{quote, ToTokens};
+
+pub fn do_for_each_example_test(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    let item: syn::ItemFn = syn::parse2(item.clone()).unwrap();
+    let mut result = proc_macro2::TokenStream::new();
+    for name in TEST_NAMES {
+        let mut item = item.clone();
+        item.sig.ident = syn::Ident::new(
+            &format!("{}_{}", item.sig.ident, name.replace('-', "_")),
+            Span::call_site(),
+        );
+        let name = name.to_owned();
+        let stmts = &item.block.stmts;
+        let block = quote! {
+            {
+                const NAME: &str = #name;
+                #(#stmts)*
+            }
+        };
+        item.block = Box::new(syn::parse2(block).unwrap());
+        result.extend(Some(item.into_token_stream()));
+    }
+
+    result
+}
+
+pub fn do_for_all_example_test(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    let mut item: syn::ItemFn = syn::parse2(item).unwrap();
+    let len = TEST_NAMES.len();
+
+    let stmts = &item.block.stmts;
+    let test_names = TEST_NAMES.iter().map(|n| n.to_owned());
+    let block = quote! {
+        {
+            const TEST_NAMES: [&str; #len] = [#(#test_names,)*];
+            #(#stmts)*
+        }
+    };
+    item.block = Box::new(syn::parse2(block).unwrap());
+
+    item.into_token_stream()
+}
+
+pub const TEST_NAMES: &[&str] = &[
+    "std-appearance-hexString-0",
+    "std-appearance-hexString-1",
+    "std-appearance-hexString-2",
+    "std-array-map-0",
+    "std-array-map-1",
+    "std-array-pop-0",
+    "std-array-push-0",
+    "std-array-reduce-0",
+    "std-array-reduce-1",
+    "std-array-reduce-2",
+    "std-clone-0",
+    "std-clone-1",
+    "std-clone-2",
+    "std-clone-3",
+    "std-clone-4",
+    "std-clone-5",
+    "std-clone-6",
+    "std-clone-7",
+    "std-clone-8",
+    "std-clone-9",
+    "std-helix-0",
+    "std-helix-1",
+    "std-helix-2",
+    "std-helix-3",
+    "std-math-abs-0",
+    "std-math-acos-0",
+    "std-math-asin-0",
+    "std-math-atan-0",
+    "std-math-atan2-0",
+    "std-math-ceil-0",
+    "std-math-cos-0",
+    "std-math-floor-0",
+    "std-math-ln-0",
+    "std-math-legLen-0",
+    "std-math-legAngX-0",
+    "std-math-legAngY-0",
+    "std-math-log-0",
+    "std-math-log10-0",
+    "std-math-log2-0",
+    "std-math-max-0",
+    "std-math-min-0",
+    "std-math-polar-0",
+    "std-math-pow-0",
+    "std-math-rem-0",
+    "std-math-round-0",
+    "std-math-sin-0",
+    "std-math-sqrt-0",
+    "std-math-tan-0",
+    "std-offsetPlane-0",
+    "std-offsetPlane-1",
+    "std-offsetPlane-2",
+    "std-offsetPlane-3",
+    "std-offsetPlane-4",
+    "std-sketch-circle-0",
+    "std-sketch-circle-1",
+    "std-sketch-patternTransform2d-0",
+    "std-sketch-revolve-0",
+    "std-sketch-revolve-1",
+    "std-sketch-revolve-10",
+    "std-sketch-revolve-11",
+    "std-sketch-revolve-12",
+    "std-sketch-revolve-2",
+    "std-sketch-revolve-3",
+    "std-sketch-revolve-4",
+    "std-sketch-revolve-5",
+    "std-sketch-revolve-6",
+    "std-sketch-revolve-7",
+    "std-sketch-revolve-8",
+    "std-sketch-revolve-9",
+    "std-solid-chamfer-0",
+    "std-solid-chamfer-1",
+    "std-solid-fillet-0",
+    "std-solid-fillet-1",
+    "std-solid-hollow-0",
+    "std-solid-hollow-1",
+    "std-solid-hollow-2",
+    "std-solid-patternTransform-0",
+    "std-solid-patternTransform-1",
+    "std-solid-patternTransform-2",
+    "std-solid-patternTransform-3",
+    "std-solid-patternTransform-4",
+    "std-solid-patternTransform-5",
+    "std-solid-shell-0",
+    "std-solid-shell-1",
+    "std-solid-shell-2",
+    "std-solid-shell-3",
+    "std-solid-shell-4",
+    "std-solid-shell-5",
+    "std-solid-shell-6",
+    "std-transform-mirror2d-0",
+    "std-transform-mirror2d-1",
+    "std-transform-mirror2d-2",
+    "std-transform-mirror2d-3",
+    "std-transform-mirror2d-4",
+    "std-units-toDegrees-0",
+    "std-units-toRadians-0",
+];

rust/kcl-derive-docs/src/lib.rs

@@ -2,16 +2,16 @@
 // automated enforcement.
 #![allow(clippy::style)]
 
+mod example_tests;
 #[cfg(test)]
 mod tests;
 mod unbox;
 
-use std::{collections::HashMap, fs};
+use std::collections::HashMap;
 
 use convert_case::Casing;
 use inflector::{cases::camelcase::to_camel_case, Inflector};
 use once_cell::sync::Lazy;
-use proc_macro2::Span;
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use regex::Regex;
 use serde::Deserialize;
@@ -28,8 +28,13 @@ pub fn stdlib(attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> p
 }
 
 #[proc_macro_attribute]
-pub fn for_each_std_mod(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+pub fn for_each_example_test(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    do_for_each_std_mod(item.into()).into()
+    example_tests::do_for_each_example_test(item.into()).into()
+}
+
+#[proc_macro_attribute]
+pub fn for_all_example_test(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    example_tests::do_for_all_example_test(item.into()).into()
 }
 
 /// Describes an argument of a stdlib function.
@@ -42,6 +47,14 @@ struct ArgMetadata {
     /// Does not do anything if the argument is already required.
     #[serde(default)]
     include_in_snippet: bool,
+
+    /// The snippet should suggest this value for the arg.
+    #[serde(default)]
+    snippet_value: Option<String>,
+
+    /// The snippet should suggest this value for the arg.
+    #[serde(default)]
+    snippet_value_array: Option<Vec<String>>,
 }
 
 #[derive(Deserialize, Debug)]
@@ -69,11 +82,6 @@ struct StdlibMetadata {
     #[serde(default)]
     feature_tree_operation: bool,
 
-    /// If true, expects keyword arguments.
-    /// If false, expects positional arguments.
-    #[serde(default)]
-    keywords: bool,
-
     /// If true, the first argument is unlabeled.
     /// If false, all arguments require labels.
     #[serde(default)]
@@ -92,34 +100,6 @@ fn do_stdlib(
     do_stdlib_inner(metadata, attr, item)
 }
 
-fn do_for_each_std_mod(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
-    let item: syn::ItemFn = syn::parse2(item.clone()).unwrap();
-    let mut result = proc_macro2::TokenStream::new();
-    for name in fs::read_dir("kcl-lib/std").unwrap().filter_map(|e| {
-        let e = e.unwrap();
-        let filename = e.file_name();
-        filename.to_str().unwrap().strip_suffix(".kcl").map(str::to_owned)
-    }) {
-        for i in 0..10_usize {
-            let mut item = item.clone();
-            item.sig.ident = syn::Ident::new(&format!("{}_{}_shard_{i}", item.sig.ident, name), Span::call_site());
-            let stmts = &item.block.stmts;
-            let block = quote! {
-                {
-                    const STD_MOD_NAME: &str = #name;
-                    const SHARD: usize = #i;
-                    const SHARD_COUNT: usize = 10;
-                    #(#stmts)*
-                }
-            };
-            item.block = Box::new(syn::parse2(block).unwrap());
-            result.extend(Some(item.into_token_stream()));
-        }
-    }
-
-    result
-}
-
 fn do_output(res: Result<(proc_macro2::TokenStream, Vec<Error>), Error>) -> proc_macro::TokenStream {
     match res {
         Err(err) => err.to_compile_error().into(),
@@ -307,12 +287,6 @@ fn do_stdlib_inner(
         quote! { false }
     };
 
-    let uses_keyword_arguments = if metadata.keywords {
-        quote! { true }
-    } else {
-        quote! { false }
-    };
-
     let docs_crate = get_crate(None);
 
     // When the user attaches this proc macro to a function with the wrong type
@@ -341,6 +315,10 @@ fn do_stdlib_inner(
         }
         .trim_start_matches('_')
         .to_string();
+        // These aren't really KCL args, they're just state that each stdlib function's impl needs.
+        if arg_name == "exec_state" || arg_name == "args" {
+            continue;
+        }
 
         let ty = match arg {
             syn::FnArg::Receiver(pat) => pat.ty.as_ref().into_token_stream(),
@@ -351,27 +329,24 @@ fn do_stdlib_inner(
 
         let ty_string = rust_type_to_openapi_type(&ty_string);
         let required = !ty_ident.to_string().starts_with("Option <");
-        let arg_meta = metadata.args.get(&arg_name);
+        let Some(arg_meta) = metadata.args.get(&arg_name) else {
-        let description = if let Some(s) = arg_meta.map(|arg| &arg.docs) {
+            errors.push(Error::new_spanned(arg, format!("arg {arg_name} not found")));
-            quote! { #s }
-        } else if metadata.keywords && ty_string != "Args" && ty_string != "ExecState" {
-            errors.push(Error::new_spanned(
-                &arg,
-                "Argument was not documented in the args block",
-            ));
             continue;
-        } else {
-            quote! { String::new() }
         };
-        let include_in_snippet = required || arg_meta.map(|arg| arg.include_in_snippet).unwrap_or_default();
+        let description = arg_meta.docs.clone();
+        let include_in_snippet = required || arg_meta.include_in_snippet;
+        let snippet_value = arg_meta.snippet_value.clone();
+        let snippet_value_array = arg_meta.snippet_value_array.clone();
+        if snippet_value.is_some() && snippet_value_array.is_some() {
+            errors.push(Error::new_spanned(arg, format!("arg {arg_name} has set both snippet_value and snippet_value array, but at most one of these may be set. Please delete one of them.")));
+        }
         let label_required = !(i == 0 && metadata.unlabeled_first);
         let camel_case_arg_name = to_camel_case(&arg_name);
         if ty_string != "ExecState" && ty_string != "Args" {
             let schema = quote! {
                 generator.root_schema_for::<#ty_ident>()
             };
-            arg_types.push(quote! {
+            let q0 = quote! {
-                #docs_crate::StdLibFnArg {
                     name: #camel_case_arg_name.to_string(),
                     type_: #ty_string.to_string(),
                     schema: #schema,
@@ -379,6 +354,32 @@ fn do_stdlib_inner(
                     label_required: #label_required,
                     description: #description.to_string(),
                     include_in_snippet: #include_in_snippet,
+            };
+            let q1 = if let Some(snippet_value) = snippet_value {
+                quote! {
+                    snippet_value: Some(#snippet_value.to_owned()),
+                }
+            } else {
+                quote! {
+                    snippet_value: None,
+                }
+            };
+            let q2 = if let Some(snippet_value_array) = snippet_value_array {
+                quote! {
+                    snippet_value_array: Some(vec![
+                        #(#snippet_value_array.to_owned()),*
+                    ]),
+                }
+            } else {
+                quote! {
+                    snippet_value_array: None,
+                }
+            };
+            arg_types.push(quote! {
+                #docs_crate::StdLibFnArg {
+                #q0
+                #q1
+                #q2
                 }
             });
         }
@@ -442,6 +443,8 @@ fn do_stdlib_inner(
                 label_required: true,
                 description: String::new(),
                 include_in_snippet: true,
+                snippet_value: None,
+                snippet_value_array: None,
             })
         }
     } else {
@@ -508,10 +511,6 @@ fn do_stdlib_inner(
                 vec![#(#tags),*]
             }
 
-            fn keyword_arguments(&self) -> bool {
-                #uses_keyword_arguments
-            }
-
             fn args(&self, inline_subschemas: bool) -> Vec<#docs_crate::StdLibFnArg> {
                 let mut settings = schemars::gen::SchemaSettings::openapi3();
                 // We set this to false so we can recurse them later.

rust/kcl-derive-docs/src/tests.rs

@@ -40,6 +40,9 @@ fn test_args_with_refs() {
     let (item, mut errors) = do_stdlib(
         quote! {
             name = "someFn",
+            args = {
+                data = { docs = "The data for this function"},
+            },
         },
         quote! {
             /// Docs
@@ -65,6 +68,9 @@ fn test_args_with_lifetime() {
     let (item, mut errors) = do_stdlib(
         quote! {
             name = "someFn",
+            args = {
+                data = { docs = "Arg for the function" },
+            }
         },
         quote! {
             /// Docs
@@ -117,7 +123,8 @@ fn test_stdlib_line_to() {
         quote! {
             name = "lineTo",
             args = {
-                sketch = { docs = "the sketch you're adding the line to" }
+                data = { docs = "the sketch you're adding the line to" },
+                sketch = { docs = "the sketch you're adding the line to" },
             }
         },
         quote! {

rust/kcl-derive-docs/tests/args_with_lifetime.gen

@@ -91,10 +91,6 @@ impl crate::docs::StdLibFn for SomeFn {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
@@ -105,8 +101,10 @@ impl crate::docs::StdLibFn for SomeFn {
             schema: generator.root_schema_for::<Foo>(),
             required: true,
             label_required: true,
-            description: String::new().to_string(),
+            description: "Arg for the function".to_string(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         }]
     }
 
@@ -123,6 +121,8 @@ impl crate::docs::StdLibFn for SomeFn {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/args_with_refs.gen

@@ -91,10 +91,6 @@ impl crate::docs::StdLibFn for SomeFn {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
@@ -105,8 +101,10 @@ impl crate::docs::StdLibFn for SomeFn {
             schema: generator.root_schema_for::<str>(),
             required: true,
             label_required: true,
-            description: String::new().to_string(),
+            description: "The data for this function".to_string(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         }]
     }
 
@@ -123,6 +121,8 @@ impl crate::docs::StdLibFn for SomeFn {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/array.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Show {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "[number]".to_string(),
-            schema: generator.root_schema_for::<[f64; 2usize]>(),
-            required: true,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: true,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Show {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/box.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Show {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "number".to_string(),
-            schema: generator.root_schema_for::<f64>(),
-            required: true,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: true,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Show {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/doc_comment_with_code.gen

@@ -93,23 +93,11 @@ impl crate::docs::StdLibFn for MyFunc {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "kittycad::types::InputFormat".to_string(),
-            schema: generator.root_schema_for::<Option<kittycad::types::InputFormat>>(),
-            required: false,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: false,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -125,6 +113,8 @@ impl crate::docs::StdLibFn for MyFunc {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/lineTo.gen

@@ -93,10 +93,6 @@ impl crate::docs::StdLibFn for LineTo {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
@@ -108,8 +104,10 @@ impl crate::docs::StdLibFn for LineTo {
                 schema: generator.root_schema_for::<LineToData>(),
                 required: true,
                 label_required: true,
-                description: String::new().to_string(),
+                description: "the sketch you're adding the line to".to_string(),
                 include_in_snippet: true,
+                snippet_value: None,
+                snippet_value_array: None,
             },
             crate::docs::StdLibFnArg {
                 name: "sketch".to_string(),
@@ -119,6 +117,8 @@ impl crate::docs::StdLibFn for LineTo {
                 label_required: true,
                 description: "the sketch you're adding the line to".to_string(),
                 include_in_snippet: true,
+                snippet_value: None,
+                snippet_value_array: None,
             },
         ]
     }
@@ -136,6 +136,8 @@ impl crate::docs::StdLibFn for LineTo {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/min.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Min {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "[number]".to_string(),
-            schema: generator.root_schema_for::<Vec<f64>>(),
-            required: true,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: true,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Min {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/option.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Show {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "number".to_string(),
-            schema: generator.root_schema_for::<Option<f64>>(),
-            required: false,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: false,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Show {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/option_input_format.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Import {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "kittycad::types::InputFormat".to_string(),
-            schema: generator.root_schema_for::<Option<kittycad::types::InputFormat>>(),
-            required: false,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: false,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Import {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/return_vec_box_sketch.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Import {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "kittycad::types::InputFormat".to_string(),
-            schema: generator.root_schema_for::<Option<kittycad::types::InputFormat>>(),
-            required: false,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: false,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Import {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/return_vec_sketch.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Import {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "kittycad::types::InputFormat".to_string(),
-            schema: generator.root_schema_for::<Option<kittycad::types::InputFormat>>(),
-            required: false,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: false,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Import {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/show.gen

@@ -92,23 +92,11 @@ impl crate::docs::StdLibFn for Show {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
         let mut generator = schemars::gen::SchemaGenerator::new(settings);
-        vec![crate::docs::StdLibFnArg {
+        vec![]
-            name: "args".to_string(),
-            type_: "[number]".to_string(),
-            schema: generator.root_schema_for::<Vec<f64>>(),
-            required: true,
-            label_required: true,
-            description: String::new().to_string(),
-            include_in_snippet: true,
-        }]
     }
 
     fn return_value(&self, inline_subschemas: bool) -> Option<crate::docs::StdLibFnArg> {
@@ -124,6 +112,8 @@ impl crate::docs::StdLibFn for Show {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

rust/kcl-derive-docs/tests/test_args_with_exec_state.gen

@@ -91,10 +91,6 @@ impl crate::docs::StdLibFn for SomeFunction {
         vec![]
     }
 
-    fn keyword_arguments(&self) -> bool {
-        false
-    }
-
     fn args(&self, inline_subschemas: bool) -> Vec<crate::docs::StdLibFnArg> {
         let mut settings = schemars::gen::SchemaSettings::openapi3();
         settings.inline_subschemas = inline_subschemas;
@@ -115,6 +111,8 @@ impl crate::docs::StdLibFn for SomeFunction {
             label_required: true,
             description: String::new(),
             include_in_snippet: true,
+            snippet_value: None,
+            snippet_value_array: None,
         })
     }
 

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.75"
+version = "0.1.77"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-language-server-release/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "kcl-language-server-release"
-version = "0.1.75"
+version = "0.1.77"
 edition = "2021"
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
 publish = false

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.75"
+version = "0.2.77"
 edition = "2021"
 license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

rust/kcl-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.75"
+version = "0.2.77"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

rust/kcl-lib/src/docs/kcl_doc.rs

@@ -10,7 +10,9 @@ use tower_lsp::lsp_types::{
 use crate::{
     execution::annotations,
     parsing::{
-        ast::types::{Annotation, ImportSelector, ItemVisibility, Node, NonCodeValue, VariableKind},
+        ast::types::{
+            Annotation, Expr, ImportSelector, ItemVisibility, LiteralValue, Node, NonCodeValue, VariableKind,
+        },
         token::NumericSuffix,
     },
     ModuleId,
@@ -293,17 +295,6 @@ impl DocData {
         }
     }
 
-    #[cfg(test)]
-    fn examples(&self) -> impl Iterator<Item = &String> {
-        match self {
-            DocData::Fn(f) => f.examples.iter(),
-            DocData::Const(c) => c.examples.iter(),
-            DocData::Ty(t) => t.examples.iter(),
-            DocData::Mod(_) => unimplemented!(),
-        }
-        .filter_map(|(s, p)| (!p.norun).then_some(s))
-    }
-
     fn expect_mod(&self) -> &ModData {
         match self {
             DocData::Mod(m) => m,
@@ -631,8 +622,6 @@ impl FnData {
             return "clone(${0:part001})".to_owned();
         } else if self.name == "hole" {
             return "hole(${0:holeSketch}, ${1:%})".to_owned();
-        } else if self.name == "circle" {
-            return "circle(center = [${0:3.14}, ${1:3.14}], diameter = ${2:3.14})".to_owned();
         }
         let mut args = Vec::new();
         let mut index = 0;
@@ -696,6 +685,8 @@ pub struct ArgData {
     /// This is helpful if the type is really basic, like "number" -- that won't tell the user much about
     /// how this argument is meant to be used.
     pub docs: Option<String>,
+    /// If given, LSP should use these as completion items.
+    pub snippet_array: Option<Vec<String>>,
 }
 
 impl fmt::Display for ArgData {
@@ -723,6 +714,7 @@ pub enum ArgKind {
 impl ArgData {
     fn from_ast(arg: &crate::parsing::ast::types::Parameter) -> Self {
         let mut result = ArgData {
+            snippet_array: Default::default(),
             name: arg.identifier.name.clone(),
             ty: arg.type_.as_ref().map(|t| t.to_string()),
             docs: None,
@@ -751,6 +743,30 @@ impl ArgData {
                                 p.value
                             );
                         }
+                    } else if p.key.name == "snippetArray" {
+                        let Expr::ArrayExpression(arr) = &p.value else {
+                            panic!(
+                                "Invalid value for `snippetArray`, expected array literal, found {:?}",
+                                p.value
+                            );
+                        };
+                        let mut items = Vec::new();
+                        for s in &arr.elements {
+                            let Expr::Literal(lit) = s else {
+                                panic!(
+                                    "Invalid value in `snippetArray`, all items must be string literals but found {:?}",
+                                    s
+                                );
+                            };
+                            let LiteralValue::String(litstr) = &lit.inner.value else {
+                                panic!(
+                                    "Invalid value in `snippetArray`, all items must be string literals but found {:?}",
+                                    s
+                                );
+                            };
+                            items.push(litstr.to_owned());
+                        }
+                        result.snippet_array = Some(items);
                     }
                 }
             }
@@ -772,6 +788,19 @@ impl ArgData {
         } else {
             format!("{} = ", self.name)
         };
+        if let Some(vals) = &self.snippet_array {
+            let mut snippet = label.to_owned();
+            snippet.push('[');
+            let n = vals.len();
+            for (i, val) in vals.iter().enumerate() {
+                snippet.push_str(&format!("${{{}:{}}}", index + i, val));
+                if i != n - 1 {
+                    snippet.push_str(", ");
+                }
+            }
+            snippet.push(']');
+            return Some((index + n - 1, snippet));
+        }
         match self.ty.as_deref() {
             Some(s) if s.starts_with("number") => Some((index, format!(r#"{label}${{{}:3.14}}"#, index))),
             Some("Point2d") => Some((
@@ -1187,7 +1216,7 @@ impl ApplyMeta for ArgData {
 
 #[cfg(test)]
 mod test {
-    use kcl_derive_docs::for_each_std_mod;
+    use kcl_derive_docs::{for_all_example_test, for_each_example_test};
 
     use super::*;
 
@@ -1225,51 +1254,81 @@ mod test {
         );
     }
 
-    #[for_each_std_mod]
+    #[for_all_example_test]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn missing_test_examples() {
+        fn check_mod(m: &ModData) {
+            for d in m.children.values() {
+                let DocData::Fn(f) = d else {
+                    continue;
+                };
+
+                for i in 0..f.examples.len() {
+                    let name = format!("{}-{i}", f.qual_name.replace("::", "-"));
+                    assert!(TEST_NAMES.contains(&&*name), "Missing test for example \"{name}\", maybe need to update kcl-derive-docs/src/example_tests.rs?")
+                }
+            }
+        }
+
+        let data = walk_prelude();
+
+        check_mod(&data);
+        for m in data.children.values() {
+            if let DocData::Mod(m) = m {
+                check_mod(m);
+            }
+        }
+    }
+
+    #[for_each_example_test]
     #[tokio::test(flavor = "multi_thread")]
     async fn kcl_test_examples() {
         let std = walk_prelude();
-        let mut errs = Vec::new();
 
-        let data = if STD_MOD_NAME == "prelude" {
+        let names = NAME.split('-');
+        let mut mods: Vec<_> = names.collect();
+        let number = mods.pop().unwrap();
+        let number: usize = number.parse().unwrap();
+        let name = mods.pop().unwrap();
+        let mut qualname = mods.join("::");
+        qualname.push_str("::");
+        qualname.push_str(name);
+
+        let data = if mods.len() == 1 {
             &std
         } else {
-            std.children
+            std.children.get(&format!("M:std::{}", mods[1])).unwrap().expect_mod()
-                .get(&format!("M:std::{STD_MOD_NAME}"))
-                .unwrap()
-                .expect_mod()
         };
 
-        let mut count = 0;
+        let Some(DocData::Fn(d)) = data.children.get(&format!("I:{qualname}")) else {
-        for d in data.children.values() {
+            panic!("Could not find data for {NAME} (missing a child entry for {qualname}), maybe need to update kcl-derive-docs/src/example_tests.rs?");
-            if let DocData::Mod(_) = d {
+        };
+
+        for (i, eg) in d.examples.iter().enumerate() {
+            if i != number {
                 continue;
             }
-
+            let result = match crate::test_server::execute_and_snapshot(&eg.0, None).await {
-            for (i, eg) in d.examples().enumerate() {
+                Err(crate::errors::ExecError::Kcl(e)) => {
-                count += 1;
+                    panic!("Error testing example {}{i}: {}", d.name, e.error.message());
-                if count % SHARD_COUNT != SHARD {
-                    continue;
                 }
-
+                Err(other_err) => panic!("{}", other_err),
-                let result = match crate::test_server::execute_and_snapshot(eg, None).await {
+                Ok(img) => img,
-                    Err(crate::errors::ExecError::Kcl(e)) => {
+            };
-                        errs.push(format!("Error testing example {}{i}: {}", d.name(), e.error.message()));
+            if eg.1.norun {
-                        continue;
+                return;
-                    }
-                    Err(other_err) => panic!("{}", other_err),
-                    Ok(img) => img,
-                };
-                twenty_twenty::assert_image(
-                    format!("tests/outputs/serial_test_example_{}{i}.png", d.example_name()),
-                    &result,
-                    0.99,
-                );
             }
+            twenty_twenty::assert_image(
+                format!(
+                    "tests/outputs/serial_test_example_fn_{}{i}.png",
+                    qualname.replace("::", "-")
+                ),
+                &result,
+                0.99,
+            );
+            return;
         }
 
-        if !errs.is_empty() {
+        panic!("Could not find data for {NAME} (no example {number}), maybe need to update kcl-derive-docs/src/example_tests.rs?");
-            panic!("{}", errs.join("\n\n"));
-        }
     }
 }

rust/kcl-lib/src/docs/mod.rs

@@ -78,8 +78,6 @@ pub struct StdLibFnData {
     pub description: String,
     /// The tags of the function.
     pub tags: Vec<String>,
-    /// If this function uses keyword arguments, or positional arguments.
-    pub keyword_arguments: bool,
     /// The args of the function.
     pub args: Vec<StdLibFnArg>,
     /// The return value of the function.
@@ -111,6 +109,13 @@ pub struct StdLibFnArg {
     /// Include this in completion snippets?
     #[serde(default, skip_serializing_if = "is_false")]
     pub include_in_snippet: bool,
+    /// Snippet should suggest this value for the argument.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snippet_value: Option<String>,
+    /// Snippet should suggest this value for the argument.
+    /// The suggested value should be an array, with these elements.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub snippet_value_array: Option<Vec<String>>,
     /// Additional information that could be used instead of the type's description.
     /// This is helpful if the type is really basic, like "u32" -- that won't tell the user much about
     /// how this argument is meant to be used.
@@ -165,6 +170,21 @@ impl StdLibFnArg {
         } else {
             ""
         };
+        if let Some(vals) = &self.snippet_value_array {
+            let mut snippet = label.to_owned();
+            snippet.push('[');
+            for (i, val) in vals.iter().enumerate() {
+                snippet.push_str(&format!("${{{}:{}}}", index + i, val));
+                if i != vals.len() - 1 {
+                    snippet.push_str(", ");
+                }
+            }
+            snippet.push(']');
+            return Ok(Some((index + vals.len() - 1, snippet)));
+        }
+        if let Some(val) = &self.snippet_value {
+            return Ok(Some((index, format!("{label}${{{}:{}}}", index, val))));
+        }
         if (self.type_ == "Sketch"
             || self.type_ == "[Sketch]"
             || self.type_ == "Geometry"
@@ -450,9 +470,6 @@ pub trait StdLibFn: std::fmt::Debug + Send + Sync {
     /// The description of the function.
     fn description(&self) -> String;
 
-    /// Does this use keyword arguments, or positional?
-    fn keyword_arguments(&self) -> bool;
-
     /// The tags of the function.
     fn tags(&self) -> Vec<String>;
 
@@ -487,7 +504,6 @@ pub trait StdLibFn: std::fmt::Debug + Send + Sync {
             summary: self.summary(),
             description: self.description(),
             tags: self.tags(),
-            keyword_arguments: self.keyword_arguments(),
             args: self.args(false),
             return_value: self.return_value(false),
             unpublished: self.unpublished(),
@@ -571,7 +587,7 @@ pub trait StdLibFn: std::fmt::Debug + Send + Sync {
         } else if self.name() == "subtract2D" {
             return Ok("subtract2d(${0:%}, tool = ${1:%})".to_string());
         }
-        let in_keyword_fn = self.keyword_arguments();
+        let in_keyword_fn = true;
         let mut args = Vec::new();
         let mut index = 0;
         for arg in self.args(true).iter() {
@@ -988,6 +1004,13 @@ mod tests {
         assert_eq!(snippet, r#"startSketchOn(${0:XY})"#);
     }
 
+    #[test]
+    fn get_autocomplete_snippet_start_profile() {
+        let start_sketch_on_fn: Box<dyn StdLibFn> = Box::new(crate::std::sketch::StartProfile);
+        let snippet = start_sketch_on_fn.to_autocomplete_snippet().unwrap();
+        assert_eq!(snippet, r#"startProfile(${0:%}, at = [${1:0}, ${2:0}])"#);
+    }
+
     #[test]
     fn get_autocomplete_snippet_pattern_circular_3d() {
         // We test this one specifically because it has ints and floats and strings.
@@ -995,7 +1018,7 @@ mod tests {
         let snippet = pattern_fn.to_autocomplete_snippet().unwrap();
         assert_eq!(
             snippet,
-            r#"patternCircular3d(${0:%}, instances = ${1:10}, axis = [${2:3.14}, ${3:3.14}, ${4:3.14}], center = [${5:3.14}, ${6:3.14}, ${7:3.14}])"#
+            r#"patternCircular3d(${0:%}, instances = ${1:10}, axis = [${2:1}, ${3:0}, ${4:0}], center = [${5:0}, ${6:0}, ${7:0}])"#
         );
     }
 
@@ -1017,8 +1040,8 @@ mod tests {
         };
         let snippet = circle_fn.to_autocomplete_snippet();
         assert_eq!(
-            snippet,
+            snippet, r#"circle(center = [${0:0}, ${1:0}], diameter = ${2:3.14})"#,
-            r#"circle(center = [${0:3.14}, ${1:3.14}], diameter = ${2:3.14})"#
+            "actual = left, expected = right"
         );
     }
 
@@ -1048,7 +1071,7 @@ mod tests {
         let snippet = pattern_fn.to_autocomplete_snippet().unwrap();
         assert_eq!(
             snippet,
-            r#"patternLinear2d(${0:%}, instances = ${1:10}, distance = ${2:3.14}, axis = [${3:3.14}, ${4:3.14}])"#
+            r#"patternLinear2d(${0:%}, instances = ${1:10}, distance = ${2:3.14}, axis = [${3:1}, ${4:0}])"#
         );
     }
 

rust/kcl-lib/src/execution/artifact.rs

@@ -20,6 +20,14 @@ use crate::{
 #[cfg(test)]
 mod mermaid_tests;
 
+macro_rules! internal_error {
+    ($range:expr, $($rest:tt)*) => {{
+        let message = format!($($rest)*);
+        debug_assert!(false, "{}", &message);
+        return Err(KclError::Internal(KclErrorDetails::new(message, vec![$range])));
+    }};
+}
+
 /// A command that may create or update artifacts on the TS side.  Because
 /// engine commands are batched, we don't have the response yet when these are
 /// created.
@@ -992,7 +1000,10 @@ fn artifacts_to_update(
             let path_id = ArtifactId::new(match cmd {
                 ModelingCmd::ClosePath(c) => c.path_id,
                 ModelingCmd::ExtendPath(e) => e.path.into(),
-                _ => unreachable!(),
+                _ => internal_error!(
+                    range,
+                    "Close or extend path command variant not handled: id={id:?}, cmd={cmd:?}"
+                ),
             });
             let mut return_arr = Vec::new();
             return_arr.push(Artifact::Segment(Segment {
@@ -1023,6 +1034,69 @@ fn artifacts_to_update(
             }
             return Ok(return_arr);
         }
+        ModelingCmd::EntityMirror(kcmc::EntityMirror {
+            ids: original_path_ids, ..
+        })
+        | ModelingCmd::EntityMirrorAcrossEdge(kcmc::EntityMirrorAcrossEdge {
+            ids: original_path_ids, ..
+        }) => {
+            let face_edge_infos = match response {
+                OkModelingCmdResponse::EntityMirror(resp) => &resp.entity_face_edge_ids,
+                OkModelingCmdResponse::EntityMirrorAcrossEdge(resp) => &resp.entity_face_edge_ids,
+                _ => internal_error!(
+                    range,
+                    "Mirror response variant not handled: id={id:?}, cmd={cmd:?}, response={response:?}"
+                ),
+            };
+            if original_path_ids.len() != face_edge_infos.len() {
+                internal_error!(range, "EntityMirror or EntityMirrorAcrossEdge response has different number face edge info than original mirrored paths: id={id:?}, cmd={cmd:?}, response={response:?}");
+            }
+            let mut return_arr = Vec::new();
+            for (face_edge_info, original_path_id) in face_edge_infos.iter().zip(original_path_ids) {
+                let original_path_id = ArtifactId::new(*original_path_id);
+                let path_id = ArtifactId::new(face_edge_info.object_id);
+                // The path may be an existing path that was extended or a new
+                // path.
+                let mut path = if let Some(Artifact::Path(path)) = artifacts.get(&path_id) {
+                    // Existing path.
+                    path.clone()
+                } else {
+                    // It's a new path.  We need the original path to get some
+                    // of its info.
+                    let Some(Artifact::Path(original_path)) = artifacts.get(&original_path_id) else {
+                        // We couldn't find the original path. This is a bug.
+                        internal_error!(range, "Couldn't find original path for mirror2d: original_path_id={original_path_id:?}, cmd={cmd:?}");
+                    };
+                    Path {
+                        id: path_id,
+                        plane_id: original_path.plane_id,
+                        seg_ids: Vec::new(),
+                        sweep_id: None,
+                        solid2d_id: None,
+                        code_ref: code_ref.clone(),
+                        composite_solid_id: None,
+                    }
+                };
+
+                face_edge_info.edges.iter().for_each(|edge_id| {
+                    let edge_id = ArtifactId::new(*edge_id);
+                    return_arr.push(Artifact::Segment(Segment {
+                        id: edge_id,
+                        path_id: path.id,
+                        surface_id: None,
+                        edge_ids: Vec::new(),
+                        edge_cut_id: None,
+                        code_ref: code_ref.clone(),
+                        common_surface_ids: Vec::new(),
+                    }));
+                    // Add the edge ID to the path.
+                    path.seg_ids.push(edge_id);
+                });
+
+                return_arr.push(Artifact::Path(path));
+            }
+            return Ok(return_arr);
+        }
         ModelingCmd::Extrude(kcmc::Extrude { target, .. })
         | ModelingCmd::Revolve(kcmc::Revolve { target, .. })
         | ModelingCmd::RevolveAboutEdge(kcmc::RevolveAboutEdge { target, .. })
@@ -1032,7 +1106,7 @@ fn artifacts_to_update(
                 ModelingCmd::Revolve(_) => SweepSubType::Revolve,
                 ModelingCmd::RevolveAboutEdge(_) => SweepSubType::RevolveAboutEdge,
                 ModelingCmd::Sweep(_) => SweepSubType::Sweep,
-                _ => unreachable!(),
+                _ => internal_error!(range, "Sweep-like command variant not handled: id={id:?}, cmd={cmd:?}",),
             };
             let mut return_arr = Vec::new();
             let target = ArtifactId::from(target);
@@ -1297,7 +1371,13 @@ fn artifacts_to_update(
             let edge_id = if let Some(edge_id) = cmd.edge_id {
                 ArtifactId::new(edge_id)
             } else {
-                cmd.edge_ids.first().unwrap().into()
+                let Some(edge_id) = cmd.edge_ids.first() else {
+                    internal_error!(
+                        range,
+                        "Solid3dFilletEdge command has no edge ID: id={id:?}, cmd={cmd:?}"
+                    );
+                };
+                edge_id.into()
             };
             return_arr.push(Artifact::EdgeCut(EdgeCut {
                 id,
@@ -1366,7 +1446,10 @@ fn artifacts_to_update(
                     let solid_ids = union.solid_ids.iter().copied().map(ArtifactId::new).collect::<Vec<_>>();
                     (CompositeSolidSubType::Union, solid_ids, Vec::new())
                 }
-                _ => unreachable!(),
+                _ => internal_error!(
+                    range,
+                    "Boolean or composite command variant not handled: id={id:?}, cmd={cmd:?}"
+                ),
             };
 
             let mut new_solid_ids = vec![id];

rust/kcl-lib/src/execution/exec_ast.rs

@@ -733,23 +733,7 @@ fn apply_ascription(
     let ty = RuntimeType::from_parsed(ty.inner.clone(), exec_state, value.into())
         .map_err(|e| KclError::Semantic(e.into()))?;
 
-    let mut value = value.clone();
+    value.coerce(&ty, false, exec_state).map_err(|_| {
-
-    // If the number has unknown units but the user is explicitly specifying them, treat the value as having had it's units erased,
-    // rather than forcing the user to explicitly erase them.
-    if let KclValue::Number { value: n, meta, .. } = &value {
-        if let RuntimeType::Primitive(PrimitiveType::Number(num)) = &ty {
-            if num.is_fully_specified() {
-                value = KclValue::Number {
-                    ty: NumericType::Any,
-                    value: *n,
-                    meta: meta.clone(),
-                };
-            }
-        }
-    }
-
-    value.coerce(&ty, exec_state).map_err(|_| {
         let suggestion = if ty == RuntimeType::length() {
             ", you might try coercing to a fully specified numeric type such as `number(mm)`"
         } else if ty == RuntimeType::angle() {
@@ -1635,8 +1619,8 @@ arr1 = [42]: [number(cm)]
             assert_eq!(*ty, RuntimeType::known_length(UnitLen::Cm));
             // Compare, ignoring meta.
             if let KclValue::Number { value, ty, .. } = &value[0] {
-                // Converted from mm to cm.
+                // It should not convert units.
-                assert_eq!(*value, 4.2);
+                assert_eq!(*value, 42.0);
                 assert_eq!(*ty, NumericType::Known(UnitType::Length(UnitLen::Cm)));
             } else {
                 panic!("Expected a number; found {:?}", value[0]);

rust/kcl-lib/src/execution/fn_call.rs

@@ -606,6 +606,7 @@ fn type_check_params_kw(
                         .value
                         .coerce(
                             &RuntimeType::from_parsed(ty.clone(), exec_state, arg.source_range).map_err(|e| KclError::Semantic(e.into()))?,
+                            true,
                             exec_state,
                         )
                         .map_err(|e| {
@@ -680,6 +681,7 @@ fn type_check_params_kw(
                 .coerce(
                     &RuntimeType::from_parsed(ty.clone(), exec_state, arg.1.source_range)
                         .map_err(|e| KclError::Semantic(e.into()))?,
+                    true,
                     exec_state,
                 )
                 .map_err(|_| {
@@ -797,7 +799,7 @@ fn coerce_result_type(
             if let RuntimeType::Array(inner, ArrayLen::NonEmpty) = &ty {
                 ty = RuntimeType::Union(vec![(**inner).clone(), ty]);
             }
-            let val = val.coerce(&ty, exec_state).map_err(|_| {
+            let val = val.coerce(&ty, true, exec_state).map_err(|_| {
                 KclError::Semantic(KclErrorDetails::new(
                     format!(
                         "This function requires its result to be of type `{}`, but found {}",

rust/kcl-lib/src/execution/types.rs

@@ -1039,19 +1039,25 @@ impl KclValue {
     ///   - result.principal_type().unwrap().subtype(ty)
     ///
     /// If self.principal_type() == ty then result == self
-    pub fn coerce(&self, ty: &RuntimeType, exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
+    pub fn coerce(
+        &self,
+        ty: &RuntimeType,
+        convert_units: bool,
+        exec_state: &mut ExecState,
+    ) -> Result<KclValue, CoercionError> {
         match ty {
-            RuntimeType::Primitive(ty) => self.coerce_to_primitive_type(ty, exec_state),
+            RuntimeType::Primitive(ty) => self.coerce_to_primitive_type(ty, convert_units, exec_state),
-            RuntimeType::Array(ty, len) => self.coerce_to_array_type(ty, *len, exec_state, false),
+            RuntimeType::Array(ty, len) => self.coerce_to_array_type(ty, convert_units, *len, exec_state, false),
-            RuntimeType::Tuple(tys) => self.coerce_to_tuple_type(tys, exec_state),
+            RuntimeType::Tuple(tys) => self.coerce_to_tuple_type(tys, convert_units, exec_state),
-            RuntimeType::Union(tys) => self.coerce_to_union_type(tys, exec_state),
+            RuntimeType::Union(tys) => self.coerce_to_union_type(tys, convert_units, exec_state),
-            RuntimeType::Object(tys) => self.coerce_to_object_type(tys, exec_state),
+            RuntimeType::Object(tys) => self.coerce_to_object_type(tys, convert_units, exec_state),
         }
     }
 
     fn coerce_to_primitive_type(
         &self,
         ty: &PrimitiveType,
+        convert_units: bool,
         exec_state: &mut ExecState,
     ) -> Result<KclValue, CoercionError> {
         let value = match self {
@@ -1060,7 +1066,29 @@ impl KclValue {
         };
         match ty {
             PrimitiveType::Any => Ok(value.clone()),
-            PrimitiveType::Number(ty) => ty.coerce(value),
+            PrimitiveType::Number(ty) => {
+                if convert_units {
+                    return ty.coerce(value);
+                }
+
+                // Instead of converting units, reinterpret the number as having
+                // different units.
+                //
+                // If the user is explicitly specifying units, treat the value
+                // as having had its units erased, rather than forcing the user
+                // to explicitly erase them.
+                if let KclValue::Number { value: n, meta, .. } = &value {
+                    if ty.is_fully_specified() {
+                        let value = KclValue::Number {
+                            ty: NumericType::Any,
+                            value: *n,
+                            meta: meta.clone(),
+                        };
+                        return ty.coerce(&value);
+                    }
+                }
+                ty.coerce(value)
+            }
             PrimitiveType::String => match value {
                 KclValue::String { .. } => Ok(value.clone()),
                 _ => Err(self.into()),
@@ -1153,10 +1181,22 @@ impl KclValue {
                     }
 
                     let origin = values.get("origin").ok_or(self.into()).and_then(|p| {
-                        p.coerce_to_array_type(&RuntimeType::length(), ArrayLen::Known(2), exec_state, true)
+                        p.coerce_to_array_type(
+                            &RuntimeType::length(),
+                            convert_units,
+                            ArrayLen::Known(2),
+                            exec_state,
+                            true,
+                        )
                     })?;
                     let direction = values.get("direction").ok_or(self.into()).and_then(|p| {
-                        p.coerce_to_array_type(&RuntimeType::length(), ArrayLen::Known(2), exec_state, true)
+                        p.coerce_to_array_type(
+                            &RuntimeType::length(),
+                            convert_units,
+                            ArrayLen::Known(2),
+                            exec_state,
+                            true,
+                        )
                     })?;
 
                     Ok(KclValue::Object {
@@ -1181,10 +1221,22 @@ impl KclValue {
                     }
 
                     let origin = values.get("origin").ok_or(self.into()).and_then(|p| {
-                        p.coerce_to_array_type(&RuntimeType::length(), ArrayLen::Known(3), exec_state, true)
+                        p.coerce_to_array_type(
+                            &RuntimeType::length(),
+                            convert_units,
+                            ArrayLen::Known(3),
+                            exec_state,
+                            true,
+                        )
                     })?;
                     let direction = values.get("direction").ok_or(self.into()).and_then(|p| {
-                        p.coerce_to_array_type(&RuntimeType::length(), ArrayLen::Known(3), exec_state, true)
+                        p.coerce_to_array_type(
+                            &RuntimeType::length(),
+                            convert_units,
+                            ArrayLen::Known(3),
+                            exec_state,
+                            true,
+                        )
                     })?;
 
                     Ok(KclValue::Object {
@@ -1221,6 +1273,7 @@ impl KclValue {
     fn coerce_to_array_type(
         &self,
         ty: &RuntimeType,
+        convert_units: bool,
         len: ArrayLen,
         exec_state: &mut ExecState,
         allow_shrink: bool,
@@ -1249,7 +1302,7 @@ impl KclValue {
                     let value_result = value
                         .iter()
                         .take(satisfied_len)
-                        .map(|v| v.coerce(ty, exec_state))
+                        .map(|v| v.coerce(ty, convert_units, exec_state))
                         .collect::<Result<Vec<_>, _>>();
 
                     if let Ok(value) = value_result {
@@ -1264,10 +1317,10 @@ impl KclValue {
                     if let KclValue::HomArray { value: inner_value, .. } = item {
                         // Flatten elements.
                         for item in inner_value {
-                            values.push(item.coerce(ty, exec_state)?);
+                            values.push(item.coerce(ty, convert_units, exec_state)?);
                         }
                     } else {
-                        values.push(item.coerce(ty, exec_state)?);
+                        values.push(item.coerce(ty, convert_units, exec_state)?);
                     }
                 }
 
@@ -1297,7 +1350,7 @@ impl KclValue {
                     .ok_or(CoercionError::from(self))?;
                 let value = value
                     .iter()
-                    .map(|item| item.coerce(ty, exec_state))
+                    .map(|item| item.coerce(ty, convert_units, exec_state))
                     .take(len)
                     .collect::<Result<Vec<_>, _>>()?;
 
@@ -1308,19 +1361,24 @@ impl KclValue {
                 ty: ty.clone(),
             }),
             _ if len.satisfied(1, false).is_some() => Ok(KclValue::HomArray {
-                value: vec![self.coerce(ty, exec_state)?],
+                value: vec![self.coerce(ty, convert_units, exec_state)?],
                 ty: ty.clone(),
             }),
             _ => Err(self.into()),
         }
     }
 
-    fn coerce_to_tuple_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
+    fn coerce_to_tuple_type(
+        &self,
+        tys: &[RuntimeType],
+        convert_units: bool,
+        exec_state: &mut ExecState,
+    ) -> Result<KclValue, CoercionError> {
         match self {
             KclValue::Tuple { value, .. } | KclValue::HomArray { value, .. } if value.len() == tys.len() => {
                 let mut result = Vec::new();
                 for (i, t) in tys.iter().enumerate() {
-                    result.push(value[i].coerce(t, exec_state)?);
+                    result.push(value[i].coerce(t, convert_units, exec_state)?);
                 }
 
                 Ok(KclValue::Tuple {
@@ -1340,9 +1398,14 @@ impl KclValue {
         }
     }
 
-    fn coerce_to_union_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Result<KclValue, CoercionError> {
+    fn coerce_to_union_type(
+        &self,
+        tys: &[RuntimeType],
+        convert_units: bool,
+        exec_state: &mut ExecState,
+    ) -> Result<KclValue, CoercionError> {
         for t in tys {
-            if let Ok(v) = self.coerce(t, exec_state) {
+            if let Ok(v) = self.coerce(t, convert_units, exec_state) {
                 return Ok(v);
             }
         }
@@ -1353,6 +1416,7 @@ impl KclValue {
     fn coerce_to_object_type(
         &self,
         tys: &[(String, RuntimeType)],
+        _convert_units: bool,
         _exec_state: &mut ExecState,
     ) -> Result<KclValue, CoercionError> {
         match self {
@@ -1461,7 +1525,7 @@ mod test {
         exec_state: &mut ExecState,
     ) {
         let is_subtype = value == expected_value;
-        assert_eq!(&value.coerce(super_type, exec_state).unwrap(), expected_value);
+        assert_eq!(&value.coerce(super_type, true, exec_state).unwrap(), expected_value);
         assert_eq!(
             is_subtype,
             value.principal_type().is_some() && value.principal_type().unwrap().subtype(super_type),
@@ -1509,10 +1573,10 @@ mod test {
                     );
                     // Coercing an empty tuple or array to an array of length 1
                     // should fail.
-                    v.coerce(&aty1, &mut exec_state).unwrap_err();
+                    v.coerce(&aty1, true, &mut exec_state).unwrap_err();
                     // Coercing an empty tuple or array to an array that's
                     // non-empty should fail.
-                    v.coerce(&aty0, &mut exec_state).unwrap_err();
+                    v.coerce(&aty0, true, &mut exec_state).unwrap_err();
                 }
                 _ => {
                     assert_coerce_results(
@@ -1560,7 +1624,7 @@ mod test {
 
         for v in &values[1..] {
             // Not a subtype
-            v.coerce(&RuntimeType::Primitive(PrimitiveType::Boolean), &mut exec_state)
+            v.coerce(&RuntimeType::Primitive(PrimitiveType::Boolean), true, &mut exec_state)
                 .unwrap_err();
         }
     }
@@ -1595,8 +1659,8 @@ mod test {
             },
             &mut exec_state,
         );
-        none.coerce(&aty1, &mut exec_state).unwrap_err();
+        none.coerce(&aty1, true, &mut exec_state).unwrap_err();
-        none.coerce(&aty1p, &mut exec_state).unwrap_err();
+        none.coerce(&aty1p, true, &mut exec_state).unwrap_err();
 
         let tty = RuntimeType::Tuple(vec![]);
         let tty1 = RuntimeType::Tuple(vec![RuntimeType::solid()]);
@@ -1609,7 +1673,7 @@ mod test {
             },
             &mut exec_state,
         );
-        none.coerce(&tty1, &mut exec_state).unwrap_err();
+        none.coerce(&tty1, true, &mut exec_state).unwrap_err();
 
         let oty = RuntimeType::Object(vec![]);
         assert_coerce_results(
@@ -1678,7 +1742,7 @@ mod test {
         assert_coerce_results(&obj2, &ty0, &obj2, &mut exec_state);
 
         let ty1 = RuntimeType::Object(vec![("foo".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        obj0.coerce(&ty1, &mut exec_state).unwrap_err();
+        obj0.coerce(&ty1, true, &mut exec_state).unwrap_err();
         assert_coerce_results(&obj1, &ty1, &obj1, &mut exec_state);
         assert_coerce_results(&obj2, &ty1, &obj2, &mut exec_state);
 
@@ -1690,19 +1754,19 @@ mod test {
             ),
             ("foo".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean)),
         ]);
-        obj0.coerce(&ty2, &mut exec_state).unwrap_err();
+        obj0.coerce(&ty2, true, &mut exec_state).unwrap_err();
-        obj1.coerce(&ty2, &mut exec_state).unwrap_err();
+        obj1.coerce(&ty2, true, &mut exec_state).unwrap_err();
         assert_coerce_results(&obj2, &ty2, &obj2, &mut exec_state);
 
         // field not present
         let tyq = RuntimeType::Object(vec![("qux".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        obj0.coerce(&tyq, &mut exec_state).unwrap_err();
+        obj0.coerce(&tyq, true, &mut exec_state).unwrap_err();
-        obj1.coerce(&tyq, &mut exec_state).unwrap_err();
+        obj1.coerce(&tyq, true, &mut exec_state).unwrap_err();
-        obj2.coerce(&tyq, &mut exec_state).unwrap_err();
+        obj2.coerce(&tyq, true, &mut exec_state).unwrap_err();
 
         // field with different type
         let ty1 = RuntimeType::Object(vec![("bar".to_owned(), RuntimeType::Primitive(PrimitiveType::Boolean))]);
-        obj2.coerce(&ty1, &mut exec_state).unwrap_err();
+        obj2.coerce(&ty1, true, &mut exec_state).unwrap_err();
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1780,8 +1844,8 @@ mod test {
         assert_coerce_results(&hom_arr, &tyh, &hom_arr, &mut exec_state);
         assert_coerce_results(&mixed1, &tym1, &mixed1, &mut exec_state);
         assert_coerce_results(&mixed2, &tym2, &mixed2, &mut exec_state);
-        mixed1.coerce(&tym2, &mut exec_state).unwrap_err();
+        mixed1.coerce(&tym2, true, &mut exec_state).unwrap_err();
-        mixed2.coerce(&tym1, &mut exec_state).unwrap_err();
+        mixed2.coerce(&tym1, true, &mut exec_state).unwrap_err();
 
         // Length subtyping
         let tyhn = RuntimeType::Array(
@@ -1798,15 +1862,15 @@ mod test {
         );
         assert_coerce_results(&hom_arr, &tyhn, &hom_arr, &mut exec_state);
         assert_coerce_results(&hom_arr, &tyh1, &hom_arr, &mut exec_state);
-        hom_arr.coerce(&tyh3, &mut exec_state).unwrap_err();
+        hom_arr.coerce(&tyh3, true, &mut exec_state).unwrap_err();
 
         let hom_arr0 = KclValue::HomArray {
             value: vec![],
             ty: RuntimeType::Primitive(PrimitiveType::Number(NumericType::count())),
         };
         assert_coerce_results(&hom_arr0, &tyhn, &hom_arr0, &mut exec_state);
-        hom_arr0.coerce(&tyh1, &mut exec_state).unwrap_err();
+        hom_arr0.coerce(&tyh1, true, &mut exec_state).unwrap_err();
-        hom_arr0.coerce(&tyh3, &mut exec_state).unwrap_err();
+        hom_arr0.coerce(&tyh3, true, &mut exec_state).unwrap_err();
 
         // Covariance
         // let tyh = RuntimeType::Array(Box::new(RuntimeType::Primitive(PrimitiveType::Number(NumericType::Any))), ArrayLen::Known(4));
@@ -1846,16 +1910,16 @@ mod test {
         assert_coerce_results(&mixed1, &tyhn, &hom_arr_2, &mut exec_state);
         assert_coerce_results(&mixed1, &tyh1, &hom_arr_2, &mut exec_state);
         assert_coerce_results(&mixed0, &tyhn, &hom_arr0, &mut exec_state);
-        mixed0.coerce(&tyh, &mut exec_state).unwrap_err();
+        mixed0.coerce(&tyh, true, &mut exec_state).unwrap_err();
-        mixed0.coerce(&tyh1, &mut exec_state).unwrap_err();
+        mixed0.coerce(&tyh1, true, &mut exec_state).unwrap_err();
 
         // Homogehous to mixed
         assert_coerce_results(&hom_arr_2, &tym1, &mixed1, &mut exec_state);
-        hom_arr.coerce(&tym1, &mut exec_state).unwrap_err();
+        hom_arr.coerce(&tym1, true, &mut exec_state).unwrap_err();
-        hom_arr_2.coerce(&tym2, &mut exec_state).unwrap_err();
+        hom_arr_2.coerce(&tym2, true, &mut exec_state).unwrap_err();
 
-        mixed0.coerce(&tym1, &mut exec_state).unwrap_err();
+        mixed0.coerce(&tym1, true, &mut exec_state).unwrap_err();
-        mixed0.coerce(&tym2, &mut exec_state).unwrap_err();
+        mixed0.coerce(&tym2, true, &mut exec_state).unwrap_err();
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1905,8 +1969,8 @@ mod test {
             RuntimeType::Primitive(PrimitiveType::Boolean),
             RuntimeType::Primitive(PrimitiveType::String),
         ]);
-        count.coerce(&tyb, &mut exec_state).unwrap_err();
+        count.coerce(&tyb, true, &mut exec_state).unwrap_err();
-        count.coerce(&tyb2, &mut exec_state).unwrap_err();
+        count.coerce(&tyb2, true, &mut exec_state).unwrap_err();
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -2021,7 +2085,7 @@ mod test {
         assert_coerce_results(&a2d, &ty2d, &a2d, &mut exec_state);
         assert_coerce_results(&a3d, &ty3d, &a3d, &mut exec_state);
         assert_coerce_results(&a3d, &ty2d, &a2d, &mut exec_state);
-        a2d.coerce(&ty3d, &mut exec_state).unwrap_err();
+        a2d.coerce(&ty3d, true, &mut exec_state).unwrap_err();
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -2084,6 +2148,7 @@ mod test {
                         angle: UnitAngle::default()
                     }
                     .into(),
+                    true,
                     &mut exec_state
                 )
                 .unwrap(),
@@ -2091,22 +2156,30 @@ mod test {
         );
 
         // No coercion
-        count.coerce(&NumericType::mm().into(), &mut exec_state).unwrap_err();
+        count
-        mm.coerce(&NumericType::count().into(), &mut exec_state).unwrap_err();
+            .coerce(&NumericType::mm().into(), true, &mut exec_state)
-        unknown.coerce(&NumericType::mm().into(), &mut exec_state).unwrap_err();
+            .unwrap_err();
+        mm.coerce(&NumericType::count().into(), true, &mut exec_state)
+            .unwrap_err();
         unknown
-            .coerce(&NumericType::default().into(), &mut exec_state)
+            .coerce(&NumericType::mm().into(), true, &mut exec_state)
+            .unwrap_err();
+        unknown
+            .coerce(&NumericType::default().into(), true, &mut exec_state)
             .unwrap_err();
 
-        count.coerce(&NumericType::Unknown.into(), &mut exec_state).unwrap_err();
+        count
-        mm.coerce(&NumericType::Unknown.into(), &mut exec_state).unwrap_err();
+            .coerce(&NumericType::Unknown.into(), true, &mut exec_state)
+            .unwrap_err();
+        mm.coerce(&NumericType::Unknown.into(), true, &mut exec_state)
+            .unwrap_err();
         default
-            .coerce(&NumericType::Unknown.into(), &mut exec_state)
+            .coerce(&NumericType::Unknown.into(), true, &mut exec_state)
             .unwrap_err();
 
         assert_eq!(
             inches
-                .coerce(&NumericType::mm().into(), &mut exec_state)
+                .coerce(&NumericType::mm().into(), true, &mut exec_state)
                 .unwrap()
                 .as_f64()
                 .unwrap()
@@ -2116,6 +2189,7 @@ mod test {
         assert_eq!(
             rads.coerce(
                 &NumericType::Known(UnitType::Angle(UnitAngle::Degrees)).into(),
+                true,
                 &mut exec_state
             )
             .unwrap()
@@ -2126,7 +2200,7 @@ mod test {
         );
         assert_eq!(
             inches
-                .coerce(&NumericType::default().into(), &mut exec_state)
+                .coerce(&NumericType::default().into(), true, &mut exec_state)
                 .unwrap()
                 .as_f64()
                 .unwrap()
@@ -2134,7 +2208,7 @@ mod test {
             1.0
         );
         assert_eq!(
-            rads.coerce(&NumericType::default().into(), &mut exec_state)
+            rads.coerce(&NumericType::default().into(), true, &mut exec_state)
                 .unwrap()
                 .as_f64()
                 .unwrap()

rust/kcl-lib/src/lsp/kcl/mod.rs

@@ -1189,6 +1189,7 @@ impl LanguageServer for Backend {
     }
 
     async fn completion(&self, params: CompletionParams) -> RpcResult<Option<CompletionResponse>> {
+        // ADAM: This is the entrypoint.
         let mut completions = vec![CompletionItem {
             label: PIPE_OPERATOR.to_string(),
             label_details: None,
@@ -1686,31 +1687,29 @@ pub fn get_arg_maps_from_stdlib(
     let combined = stdlib.combined();
 
     for internal_fn in combined.values() {
-        if internal_fn.keyword_arguments() {
+        let arg_map: HashMap<String, String> = internal_fn
-            let arg_map: HashMap<String, String> = internal_fn
+            .args(false)
-                .args(false)
+            .into_iter()
-                .into_iter()
+            .map(|data| {
-                .map(|data| {
+                let mut tip = "```\n".to_owned();
-                    let mut tip = "```\n".to_owned();
+                tip.push_str(&data.name.clone());
-                    tip.push_str(&data.name.clone());
+                if !data.required {
-                    if !data.required {
+                    tip.push('?');
-                        tip.push('?');
+                }
-                    }
+                if !data.type_.is_empty() {
-                    if !data.type_.is_empty() {
+                    tip.push_str(": ");
-                        tip.push_str(": ");
+                    tip.push_str(&data.type_);
-                        tip.push_str(&data.type_);
+                }
-                    }
+                tip.push_str("\n```");
-                    tip.push_str("\n```");
+                if !data.description.is_empty() {
-                    if !data.description.is_empty() {
+                    tip.push_str("\n\n");
-                        tip.push_str("\n\n");
+                    tip.push_str(&data.description);
-                        tip.push_str(&data.description);
+                }
-                    }
+                (data.name, tip)
-                    (data.name, tip)
+            })
-                })
+            .collect();
-                .collect();
+        if !arg_map.is_empty() {
-            if !arg_map.is_empty() {
+            result.insert(internal_fn.name(), arg_map);
-                result.insert(internal_fn.name(), arg_map);
-            }
         }
     }
 

rust/kcl-lib/src/modules.rs

@@ -97,6 +97,7 @@ pub(crate) fn read_std(mod_name: &str) -> Option<&'static str> {
         "units" => Some(include_str!("../std/units.kcl")),
         "array" => Some(include_str!("../std/array.kcl")),
         "sweep" => Some(include_str!("../std/sweep.kcl")),
+        "appearance" => Some(include_str!("../std/appearance.kcl")),
         "transform" => Some(include_str!("../std/transform.kcl")),
         _ => None,
     }

rust/kcl-lib/src/parsing/parser.rs

@@ -886,7 +886,7 @@ fn array_end_start(i: &mut TokenSlice) -> PResult<Node<ArrayRangeExpression>> {
     ignore_whitespace(i);
     let start_element = expression.parse_next(i)?;
     ignore_whitespace(i);
-    double_period.parse_next(i)?;
+    let end_inclusive = alt((end_inclusive_range.map(|_| true), end_exclusive_range.map(|_| false))).parse_next(i)?;
     ignore_whitespace(i);
     let end_element = expression.parse_next(i)?;
     ignore_whitespace(i);
@@ -895,7 +895,7 @@ fn array_end_start(i: &mut TokenSlice) -> PResult<Node<ArrayRangeExpression>> {
         ArrayRangeExpression {
             start_element,
             end_element,
-            end_inclusive: true,
+            end_inclusive,
             digest: None,
         },
         start,
@@ -2705,7 +2705,7 @@ fn period(i: &mut TokenSlice) -> PResult<()> {
     Ok(())
 }
 
-fn double_period(i: &mut TokenSlice) -> PResult<Token> {
+fn end_inclusive_range(i: &mut TokenSlice) -> PResult<Token> {
     any.try_map(|token: Token| {
         if matches!(token.token_type, TokenType::DoublePeriod) {
             Ok(token)
@@ -2724,6 +2724,21 @@ fn double_period(i: &mut TokenSlice) -> PResult<Token> {
     .parse_next(i)
 }
 
+fn end_exclusive_range(i: &mut TokenSlice) -> PResult<Token> {
+    any.try_map(|token: Token| {
+        if matches!(token.token_type, TokenType::DoublePeriodLessThan) {
+            Ok(token)
+        } else {
+            Err(CompilationError::fatal(
+                token.as_source_range(),
+                format!("expected a '..<' but found {}", token.value.as_str()),
+            ))
+        }
+    })
+    .context(expected("the ..< operator, used for array ranges like [0..<10]"))
+    .parse_next(i)
+}
+
 fn colon(i: &mut TokenSlice) -> PResult<Token> {
     TokenType::Colon.parse_from(i)
 }
@@ -5344,7 +5359,6 @@ mod snapshot_tests {
     );
     snapshot_test!(aa, r#"sg = -scale"#);
     snapshot_test!(ab, "line(endAbsolute = [0, -1])");
-    snapshot_test!(ac, "myArray = [0..10]");
     snapshot_test!(
         ad,
         r#"
@@ -5485,6 +5499,11 @@ my14 = 4 ^ 2 - 3 ^ 2 * 2
            )"#
     );
     snapshot_test!(kw_function_in_binary_op, r#"val = f(x = 1) + 1"#);
+    snapshot_test!(
+        array_ranges,
+        r#"incl = [1..10]
+        excl = [0..<10]"#
+    );
 }
 
 #[allow(unused)]

rust/kcl-lib/src/parsing/snapshots/kcl_lib__parsing__parser__snapshot_tests__array_ranges.snap

@@ -0,0 +1,117 @@
+---
+source: kcl-lib/src/parsing/parser.rs
+expression: actual
+---
+{
+  "body": [
+    {
+      "commentStart": 0,
+      "declaration": {
+        "commentStart": 0,
+        "end": 14,
+        "id": {
+          "commentStart": 0,
+          "end": 4,
+          "name": "incl",
+          "start": 0,
+          "type": "Identifier"
+        },
+        "init": {
+          "commentStart": 7,
+          "end": 14,
+          "endElement": {
+            "commentStart": 11,
+            "end": 13,
+            "raw": "10",
+            "start": 11,
+            "type": "Literal",
+            "type": "Literal",
+            "value": {
+              "value": 10.0,
+              "suffix": "None"
+            }
+          },
+          "endInclusive": true,
+          "start": 7,
+          "startElement": {
+            "commentStart": 8,
+            "end": 9,
+            "raw": "1",
+            "start": 8,
+            "type": "Literal",
+            "type": "Literal",
+            "value": {
+              "value": 1.0,
+              "suffix": "None"
+            }
+          },
+          "type": "ArrayRangeExpression",
+          "type": "ArrayRangeExpression"
+        },
+        "start": 0,
+        "type": "VariableDeclarator"
+      },
+      "end": 14,
+      "kind": "const",
+      "start": 0,
+      "type": "VariableDeclaration",
+      "type": "VariableDeclaration"
+    },
+    {
+      "commentStart": 23,
+      "declaration": {
+        "commentStart": 23,
+        "end": 38,
+        "id": {
+          "commentStart": 23,
+          "end": 27,
+          "name": "excl",
+          "start": 23,
+          "type": "Identifier"
+        },
+        "init": {
+          "commentStart": 30,
+          "end": 38,
+          "endElement": {
+            "commentStart": 35,
+            "end": 37,
+            "raw": "10",
+            "start": 35,
+            "type": "Literal",
+            "type": "Literal",
+            "value": {
+              "value": 10.0,
+              "suffix": "None"
+            }
+          },
+          "endInclusive": false,
+          "start": 30,
+          "startElement": {
+            "commentStart": 31,
+            "end": 32,
+            "raw": "0",
+            "start": 31,
+            "type": "Literal",
+            "type": "Literal",
+            "value": {
+              "value": 0.0,
+              "suffix": "None"
+            }
+          },
+          "type": "ArrayRangeExpression",
+          "type": "ArrayRangeExpression"
+        },
+        "start": 23,
+        "type": "VariableDeclarator"
+      },
+      "end": 38,
+      "kind": "const",
+      "start": 23,
+      "type": "VariableDeclaration",
+      "type": "VariableDeclaration"
+    }
+  ],
+  "commentStart": 0,
+  "end": 38,
+  "start": 0
+}

rust/kcl-lib/src/parsing/token/mod.rs

@@ -369,6 +369,8 @@ pub enum TokenType {
     Period,
     /// A double period: `..`.
     DoublePeriod,
+    /// A double period and a less than: `..<`.
+    DoublePeriodLessThan,
     /// A line comment.
     LineComment,
     /// A block comment.
@@ -410,6 +412,7 @@ impl TryFrom<TokenType> for SemanticTokenType {
             | TokenType::DoubleColon
             | TokenType::Period
             | TokenType::DoublePeriod
+            | TokenType::DoublePeriodLessThan
             | TokenType::Hash
             | TokenType::Dollar
             | TokenType::At

rust/kcl-lib/src/parsing/token/tokeniser.rs

@@ -87,7 +87,7 @@ pub(super) fn token(i: &mut Input<'_>) -> PResult<Token> {
         '0'..='9' => number,
         ';' => semi_colon,
         ':' => alt((double_colon, colon)),
-        '.' => alt((number, double_period, period)),
+        '.' => alt((number, double_period_less_than, double_period, period)),
         '#' => hash,
         '$' => dollar,
         '!' => alt((operator, bang)),
@@ -320,6 +320,16 @@ fn double_period(i: &mut Input<'_>) -> PResult<Token> {
     ))
 }
 
+fn double_period_less_than(i: &mut Input<'_>) -> PResult<Token> {
+    let (value, range) = "..<".with_span().parse_next(i)?;
+    Ok(Token::from_range(
+        range,
+        i.state.module_id,
+        TokenType::DoublePeriodLessThan,
+        value.to_string(),
+    ))
+}
+
 /// Zero or more of either:
 /// 1. Any character except " or \
 /// 2. Any character preceded by \

rust/kcl-lib/src/simulation_tests.rs

@@ -26,6 +26,10 @@ struct Test {
     input_dir: PathBuf,
     /// Expected snapshot output files are in this directory.
     output_dir: PathBuf,
+    /// True to skip asserting the artifact graph and only write it. The default
+    /// is false and to assert it.
+    #[cfg_attr(not(feature = "artifact-graph"), expect(dead_code))]
+    skip_assert_artifact_graph: bool,
 }
 
 pub(crate) const RENDERED_MODEL_NAME: &str = "rendered_model.png";
@@ -37,6 +41,7 @@ impl Test {
             entry_point: Path::new("tests").join(name).join("input.kcl"),
             input_dir: Path::new("tests").join(name),
             output_dir: Path::new("tests").join(name),
+            skip_assert_artifact_graph: false,
         }
     }
 
@@ -299,21 +304,28 @@ fn assert_common_snapshots(
         })
     }));
     let result3 = catch_unwind(AssertUnwindSafe(|| {
-        assert_snapshot(test, "Artifact graph flowchart", || {
+        // If the user is explicitly writing, we always want to run so that they
-            let mut artifact_graph = artifact_graph.clone();
+        // can save new expected output.  There's no way to reliably determine
-            // Sort the map by artifact where we can.
+        // if insta will write, as far as I can tell, so we use our own
-            artifact_graph.sort();
+        // environment variable.
+        let is_writing = matches!(std::env::var("ZOO_SIM_UPDATE").as_deref(), Ok("always"));
+        if !test.skip_assert_artifact_graph || is_writing {
+            assert_snapshot(test, "Artifact graph flowchart", || {
+                let mut artifact_graph = artifact_graph.clone();
+                // Sort the map by artifact where we can.
+                artifact_graph.sort();
 
-            let flowchart = artifact_graph
+                let flowchart = artifact_graph
-                .to_mermaid_flowchart()
+                    .to_mermaid_flowchart()
-                .unwrap_or_else(|e| format!("Failed to convert artifact graph to flowchart: {e}"));
+                    .unwrap_or_else(|e| format!("Failed to convert artifact graph to flowchart: {e}"));
-            // Change the snapshot suffix so that it is rendered as a Markdown file
+                // Change the snapshot suffix so that it is rendered as a Markdown file
-            // in GitHub.
+                // in GitHub.
-            // Ignore the cpu cooler for now because its being a little bitch.
+                // Ignore the cpu cooler for now because its being a little bitch.
-            if test.name != "cpu-cooler" {
+                if test.name != "cpu-cooler" && test.name != "subtract_regression10" {
-                insta::assert_binary_snapshot!("artifact_graph_flowchart.md", flowchart.as_bytes().to_owned());
+                    insta::assert_binary_snapshot!("artifact_graph_flowchart.md", flowchart.as_bytes().to_owned());
-            }
+                }
-        })
+            })
+        }
     }));
 
     result1.unwrap();

rust/kcl-lib/src/simulation_tests/kcl_samples.rs

@@ -145,6 +145,8 @@ fn test(test_name: &str, entry_point: std::path::PathBuf) -> Test {
         entry_point: entry_point.clone(),
         input_dir: parent.to_path_buf(),
         output_dir: relative_output_dir,
+        // Skip is temporary while we have non-deterministic output.
+        skip_assert_artifact_graph: true,
     }
 }
 

rust/kcl-lib/src/std/appearance.rs

@@ -10,7 +10,10 @@ use rgba_simple::Hex;
 use super::args::TyF64;
 use crate::{
     errors::{KclError, KclErrorDetails},
-    execution::{types::RuntimeType, ExecState, KclValue, SolidOrImportedGeometry},
+    execution::{
+        types::{ArrayLen, RuntimeType},
+        ExecState, KclValue, SolidOrImportedGeometry,
+    },
     std::Args,
 };
 
@@ -18,6 +21,34 @@ lazy_static::lazy_static! {
     static ref HEX_REGEX: Regex = Regex::new(r"^#[0-9a-fA-F]{6}$").unwrap();
 }
 
+/// Construct a color from its red, blue and green components.
+pub async fn hex_string(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+    let rgb: [TyF64; 3] = args.get_unlabeled_kw_arg_typed(
+        "rgb",
+        &RuntimeType::Array(Box::new(RuntimeType::count()), ArrayLen::Known(3)),
+        exec_state,
+    )?;
+
+    // Make sure the color if set is valid.
+    if let Some(component) = rgb.iter().find(|component| component.n < 0.0 || component.n > 255.0) {
+        return Err(KclError::Semantic(KclErrorDetails::new(
+            format!("Colors are given between 0 and 255, so {} is invalid", component.n),
+            vec![args.source_range],
+        )));
+    }
+
+    inner_hex_string(rgb, exec_state, args).await
+}
+
+async fn inner_hex_string(rgb: [TyF64; 3], _: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
+    let [r, g, b] = rgb.map(|n| n.n.floor() as u32);
+    let s = format!("#{r:02x}{g:02x}{b:02x}");
+    Ok(KclValue::String {
+        value: s,
+        meta: args.into(),
+    })
+}
+
 /// Set the appearance of a solid. This only works on solids, not sketches or individual paths.
 pub async fn appearance(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
     let solids = args.get_unlabeled_kw_arg_typed(
@@ -260,7 +291,6 @@ pub async fn appearance(exec_state: &mut ExecState, args: Args) -> Result<KclVal
 /// ```
 #[stdlib {
     name = "appearance",
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = { docs = "The solid(s) whose appearance is being set" },

rust/kcl-lib/src/std/args.rs

@@ -177,7 +177,7 @@ impl Args {
             )));
         };
 
-        let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
+        let arg = arg.value.coerce(ty, true, exec_state).map_err(|_| {
             let actual_type = arg.value.principal_type();
             let actual_type_name = actual_type
                 .as_ref()
@@ -297,7 +297,7 @@ impl Args {
                 vec![self.source_range],
             )))?;
 
-        let arg = arg.value.coerce(ty, exec_state).map_err(|_| {
+        let arg = arg.value.coerce(ty, true, exec_state).map_err(|_| {
             let actual_type = arg.value.principal_type();
             let actual_type_name = actual_type
                 .as_ref()

rust/kcl-lib/src/std/assert.rs

@@ -49,7 +49,6 @@ pub async fn assert(_exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// ```
 #[stdlib{
     name = "assertIs",
-    keywords = true,
     unlabeled_first = true,
     args = {
         actual = { docs = "Value to check. If this is the boolean value true, assert passes. Otherwise it fails." },
@@ -75,7 +74,6 @@ async fn inner_assert_is(actual: bool, error: Option<String>, args: &Args) -> Re
 /// ```
 #[stdlib {
     name = "assert",
-    keywords = true,
     unlabeled_first = true,
     args = {
         actual = { docs = "Value to check. It will be compared with one of the comparison arguments." },

rust/kcl-lib/src/std/csg.rs

@@ -106,7 +106,6 @@ pub async fn union(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 #[stdlib {
     name = "union",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = {docs = "The solids to union."},
@@ -232,7 +231,6 @@ pub async fn intersect(exec_state: &mut ExecState, args: Args) -> Result<KclValu
 #[stdlib {
     name = "intersect",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = {docs = "The solids to intersect."},
@@ -352,7 +350,6 @@ pub async fn subtract(exec_state: &mut ExecState, args: Args) -> Result<KclValue
 #[stdlib {
     name = "subtract",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = {docs = "The solids to use as the base to subtract from."},

rust/kcl-lib/src/std/edge.rs

@@ -53,7 +53,6 @@ pub async fn get_opposite_edge(exec_state: &mut ExecState, args: Args) -> Result
 /// ```
 #[stdlib {
     name = "getOppositeEdge",
-    keywords = true,
     unlabeled_first = true,
     args = {
         edge = { docs = "The tag of the edge you want to find the opposite edge of." },
@@ -137,7 +136,6 @@ pub async fn get_next_adjacent_edge(exec_state: &mut ExecState, args: Args) -> R
 /// ```
 #[stdlib {
     name = "getNextAdjacentEdge",
-    keywords = true,
     unlabeled_first = true,
     args = {
         edge = { docs = "The tag of the edge you want to find the next adjacent edge of." },
@@ -230,7 +228,6 @@ pub async fn get_previous_adjacent_edge(exec_state: &mut ExecState, args: Args)
 /// ```
 #[stdlib {
     name = "getPreviousAdjacentEdge",
-    keywords = true,
     unlabeled_first = true,
     args = {
         edge = { docs = "The tag of the edge you want to find the previous adjacent edge of." },
@@ -318,7 +315,6 @@ pub async fn get_common_edge(exec_state: &mut ExecState, args: Args) -> Result<K
 #[stdlib {
     name = "getCommonEdge",
     feature_tree_operation = false,
-    keywords = true,
     unlabeled_first = false,
     args = {
         faces = { docs = "The tags of the faces you want to find the common edge between" },

rust/kcl-lib/src/std/extrude.rs

@@ -148,7 +148,6 @@ pub async fn extrude(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 #[stdlib {
     name = "extrude",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketches = { docs = "Which sketch or sketches should be extruded"},

rust/kcl-lib/src/std/fillet.rs

@@ -82,43 +82,67 @@ async fn inner_fillet(
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Box<Solid>, KclError> {
+    // If you try and tag multiple edges with a tagged fillet, we want to return an
+    // error to the user that they can only tag one edge at a time.
+    if tag.is_some() && tags.len() > 1 {
+        return Err(KclError::Type(KclErrorDetails {
+            message: "You can only tag one edge at a time with a tagged fillet. Either delete the tag for the fillet fn if you don't need it OR separate into individual fillet functions for each tag.".to_string(),
+            source_ranges: vec![args.source_range],
+            backtrace: Default::default(),
+        }));
+    }
+    if tags.is_empty() {
+        return Err(KclError::Semantic(KclErrorDetails {
+            source_ranges: vec![args.source_range],
+            message: "You must fillet at least one tag".to_owned(),
+            backtrace: Default::default(),
+        }));
+    }
+
     let mut solid = solid.clone();
-    for edge_tag in tags {
+    let edge_ids = tags
-        let edge_id = edge_tag.get_engine_id(exec_state, &args)?;
+        .into_iter()
+        .map(|edge_tag| edge_tag.get_engine_id(exec_state, &args))
+        .collect::<Result<Vec<_>, _>>()?;
 
-        let id = exec_state.next_uuid();
+    let id = exec_state.next_uuid();
-        args.batch_end_cmd(
+    let mut extra_face_ids = Vec::new();
-            id,
+    let num_extra_ids = edge_ids.len() - 1;
-            ModelingCmd::from(mcmd::Solid3dFilletEdge {
+    for _ in 0..num_extra_ids {
-                edge_id: None,
+        extra_face_ids.push(exec_state.next_uuid());
-                edge_ids: vec![edge_id],
+    }
-                extra_face_ids: vec![],
+    args.batch_end_cmd(
-                strategy: Default::default(),
+        id,
-                object_id: solid.id,
+        ModelingCmd::from(mcmd::Solid3dFilletEdge {
-                radius: LengthUnit(radius.to_mm()),
+            edge_id: None,
-                tolerance: LengthUnit(tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE)),
+            edge_ids: edge_ids.clone(),
-                cut_type: CutType::Fillet,
+            extra_face_ids,
-            }),
+            strategy: Default::default(),
-        )
+            object_id: solid.id,
-        .await?;
+            radius: LengthUnit(radius.to_mm()),
+            tolerance: LengthUnit(tolerance.as_ref().map(|t| t.to_mm()).unwrap_or(DEFAULT_TOLERANCE)),
+            cut_type: CutType::Fillet,
+        }),
+    )
+    .await?;
 
-        solid.edge_cuts.push(EdgeCut::Fillet {
+    let new_edge_cuts = edge_ids.into_iter().map(|edge_id| EdgeCut::Fillet {
-            id,
+        id,
-            edge_id,
+        edge_id,
-            radius: radius.clone(),
+        radius: radius.clone(),
-            tag: Box::new(tag.clone()),
+        tag: Box::new(tag.clone()),
-        });
+    });
+    solid.edge_cuts.extend(new_edge_cuts);
 
-        if let Some(ref tag) = tag {
+    if let Some(ref tag) = tag {
-            solid.value.push(ExtrudeSurface::Fillet(FilletSurface {
+        solid.value.push(ExtrudeSurface::Fillet(FilletSurface {
-                face_id: id,
+            face_id: id,
-                tag: Some(tag.clone()),
+            tag: Some(tag.clone()),
-                geo_meta: GeoMeta {
+            geo_meta: GeoMeta {
-                    id,
+                id,
-                    metadata: args.source_range.into(),
+                metadata: args.source_range.into(),
-                },
+            },
-            }));
+        }));
-        }
     }
 
     Ok(solid)

rust/kcl-lib/src/std/loft.rs

@@ -121,7 +121,6 @@ pub async fn loft(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
 #[stdlib {
     name = "loft",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketches = {docs = "Which sketches to loft. Must include at least 2 sketches."},

rust/kcl-lib/src/std/mod.rs

@@ -286,7 +286,13 @@ pub(crate) fn std_fn(path: &str, fn_name: &str) -> (crate::std::StdFn, StdFnProp
             |e, a| Box::pin(crate::std::patterns::pattern_transform_2d(e, a)),
             StdFnProps::default("std::sketch::patternTransform2d"),
         ),
-        _ => unreachable!(),
+        ("appearance", "hexString") => (
+            |e, a| Box::pin(crate::std::appearance::hex_string(e, a)),
+            StdFnProps::default("std::appearance::hexString"),
+        ),
+        (module, fn_name) => {
+            panic!("No implementation found for {module}::{fn_name}, please add it to this big match statement")
+        }
     }
 }
 

rust/kcl-lib/src/std/patterns.rs

@@ -344,7 +344,7 @@ fn array_to_point3d(
     source_ranges: Vec<SourceRange>,
     exec_state: &mut ExecState,
 ) -> Result<[TyF64; 3], KclError> {
-    val.coerce(&RuntimeType::point3d(), exec_state)
+    val.coerce(&RuntimeType::point3d(), true, exec_state)
         .map_err(|e| {
             KclError::Semantic(KclErrorDetails::new(
                 format!(
@@ -364,7 +364,7 @@ fn array_to_point2d(
     source_ranges: Vec<SourceRange>,
     exec_state: &mut ExecState,
 ) -> Result<[TyF64; 2], KclError> {
-    val.coerce(&RuntimeType::point2d(), exec_state)
+    val.coerce(&RuntimeType::point2d(), true, exec_state)
         .map_err(|e| {
             KclError::Semantic(KclErrorDetails::new(
                 format!(
@@ -578,13 +578,12 @@ pub async fn pattern_linear_2d(exec_state: &mut ExecState, args: Args) -> Result
 /// ```
 #[stdlib {
     name = "patternLinear2d",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketches = { docs = "The sketch(es) to duplicate" },
         instances = { docs = "The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect." },
         distance = { docs = "Distance between each repetition. Also known as 'spacing'."},
-        axis = { docs = "The axis of the pattern. A 2D vector." },
+        axis = { docs = "The axis of the pattern. A 2D vector.", snippet_value_array = ["1", "0"] },
         use_original = { docs = "If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false." },
     }
 }]
@@ -742,13 +741,12 @@ pub async fn pattern_linear_3d(exec_state: &mut ExecState, args: Args) -> Result
 #[stdlib {
     name = "patternLinear3d",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = { docs = "The solid(s) to duplicate" },
         instances = { docs = "The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect." },
         distance = { docs = "Distance between each repetition. Also known as 'spacing'."},
-        axis = { docs = "The axis of the pattern. A 2D vector." },
+        axis = { docs = "The axis of the pattern. A 3D vector.", snippet_value_array = ["1", "0", "0"] },
         use_original = { docs = "If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false." },
     },
     tags = ["solid"]
@@ -939,12 +937,11 @@ pub async fn pattern_circular_2d(exec_state: &mut ExecState, args: Args) -> Resu
 /// ```
 #[stdlib {
     name = "patternCircular2d",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch_set = { docs = "Which sketch(es) to pattern" },
         instances = { docs = "The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect."},
-        center = { docs = "The center about which to make the pattern. This is a 2D vector."},
+        center = { docs = "The center about which to make the pattern. This is a 2D vector.", snippet_value_array = ["0", "0"]},
         arc_degrees = { docs = "The arc angle (in degrees) to place the repetitions. Must be greater than 0. Defaults to 360."},
         rotate_duplicates= { docs = "Whether or not to rotate the duplicates as they are copied. Defaults to true."},
         use_original= { docs = "If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false."},
@@ -1081,13 +1078,12 @@ pub async fn pattern_circular_3d(exec_state: &mut ExecState, args: Args) -> Resu
 #[stdlib {
     name = "patternCircular3d",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         solids = { docs = "Which solid(s) to pattern" },
         instances = { docs = "The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect."},
-        axis = { docs = "The axis around which to make the pattern. This is a 3D vector"},
+        axis = { docs = "The axis around which to make the pattern. This is a 3D vector", snippet_value_array = ["1", "0", "0"]},
-        center = { docs = "The center about which to make the pattern. This is a 3D vector."},
+        center = { docs = "The center about which to make the pattern. This is a 3D vector.", snippet_value_array = ["0", "0", "0"]},
         arc_degrees = { docs = "The arc angle (in degrees) to place the repetitions. Must be greater than 0. Defaults to 360."},
         rotate_duplicates = { docs = "Whether or not to rotate the duplicates as they are copied. Defaults to true."},
         use_original = { docs = "If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false."},

rust/kcl-lib/src/std/segment.rs

@@ -49,7 +49,6 @@ pub async fn segment_end(exec_state: &mut ExecState, args: Args) -> Result<KclVa
 /// ```
 #[stdlib {
     name = "segEnd",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -94,7 +93,6 @@ pub async fn segment_end_x(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "segEndX",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -137,7 +135,6 @@ pub async fn segment_end_y(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "segEndY",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -191,7 +188,6 @@ pub async fn segment_start(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "segStart",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -236,7 +232,6 @@ pub async fn segment_start_x(exec_state: &mut ExecState, args: Args) -> Result<K
 /// ```
 #[stdlib {
     name = "segStartX",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -279,7 +274,6 @@ pub async fn segment_start_y(exec_state: &mut ExecState, args: Args) -> Result<K
 /// ```
 #[stdlib {
     name = "segStartY",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -322,7 +316,6 @@ pub async fn last_segment_x(exec_state: &mut ExecState, args: Args) -> Result<Kc
 /// ```
 #[stdlib {
     name = "lastSegX",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "The sketch whose line segment is being queried"},
@@ -369,7 +362,6 @@ pub async fn last_segment_y(exec_state: &mut ExecState, args: Args) -> Result<Kc
 /// ```
 #[stdlib {
     name = "lastSegY",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "The sketch whose line segment is being queried"},
@@ -419,7 +411,6 @@ pub async fn segment_length(exec_state: &mut ExecState, args: Args) -> Result<Kc
 /// ```
 #[stdlib {
     name = "segLen",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -463,7 +454,6 @@ pub async fn segment_angle(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "segAng",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},
@@ -565,7 +555,6 @@ pub async fn tangent_to_end(exec_state: &mut ExecState, args: Args) -> Result<Kc
 /// ```
 #[stdlib {
     name = "tangentToEnd",
-    keywords = true,
     unlabeled_first = true,
     args = {
         tag = { docs = "The line segment being queried by its tag"},

rust/kcl-lib/src/std/shapes.rs

@@ -167,7 +167,6 @@ pub async fn circle_three_point(exec_state: &mut ExecState, args: Args) -> Resul
 /// ```
 #[stdlib {
     name = "circleThreePoint",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch_surface_or_group = {docs = "Plane or surface to sketch on."},
@@ -324,13 +323,12 @@ pub async fn polygon(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// ```
 #[stdlib {
     name = "polygon",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch_surface_or_group = { docs = "Plane or surface to sketch on" },
         radius = { docs = "The radius of the polygon", include_in_snippet = true },
         num_sides = { docs = "The number of sides in the polygon", include_in_snippet = true },
-        center = { docs = "The center point of the polygon", include_in_snippet = true },
+        center = { docs = "The center point of the polygon", snippet_value_array = ["0", "0"] },
         inscribed = { docs = "Whether the polygon is inscribed (true, the default) or circumscribed (false) about a circle with the specified radius" },
     },
     tags = ["sketch"]

rust/kcl-lib/src/std/sketch.rs

@@ -133,7 +133,6 @@ fn involute_curve(radius: f64, angle: f64) -> (f64, f64) {
 /// ```
 #[stdlib {
     name = "involuteCircular",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -254,7 +253,6 @@ pub async fn line(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kc
 /// ```
 #[stdlib {
     name = "line",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -426,7 +424,6 @@ pub async fn x_line(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// ```
 #[stdlib {
     name = "xLine",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -492,7 +489,6 @@ pub async fn y_line(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 /// ```
 #[stdlib {
     name = "yLine",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -575,7 +571,6 @@ pub async fn angled_line(exec_state: &mut ExecState, args: Args) -> Result<KclVa
 /// ```
 #[stdlib {
     name = "angledLine",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -874,7 +869,6 @@ pub async fn angled_line_that_intersects(exec_state: &mut ExecState, args: Args)
 /// ```
 #[stdlib {
     name = "angledLineThatIntersects",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -1152,7 +1146,6 @@ pub async fn start_sketch_on(exec_state: &mut ExecState, args: Args) -> Result<K
 #[stdlib {
     name = "startSketchOn",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         plane_or_solid = { docs = "The plane or solid to sketch on"},
@@ -1318,11 +1311,10 @@ pub async fn start_profile(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "startProfile",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch_surface = { docs = "What to start the profile on" },
-        at = { docs = "Where to start the profile. An absolute point." },
+        at = { docs = "Where to start the profile. An absolute point.", snippet_value_array = ["0", "0"] },
         tag = { docs = "Tag this first starting point" },
     },
     tags = ["sketch"]
@@ -1461,7 +1453,6 @@ pub async fn profile_start_x(exec_state: &mut ExecState, args: Args) -> Result<K
 /// ```
 #[stdlib {
     name = "profileStartX",
-    keywords = true,
     unlabeled_first = true,
     args = {
         profile = {docs = "Profile whose start is being used"},
@@ -1491,7 +1482,6 @@ pub async fn profile_start_y(exec_state: &mut ExecState, args: Args) -> Result<K
 /// ```
 #[stdlib {
     name = "profileStartY",
-    keywords = true,
     unlabeled_first = true,
     args = {
         profile = {docs = "Profile whose start is being used"},
@@ -1524,7 +1514,6 @@ pub async fn profile_start(exec_state: &mut ExecState, args: Args) -> Result<Kcl
 /// ```
 #[stdlib {
     name = "profileStart",
-    keywords = true,
     unlabeled_first = true,
     args = {
         profile = {docs = "Profile whose start is being used"},
@@ -1569,7 +1558,6 @@ pub async fn close(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 /// ```
 #[stdlib {
     name = "close",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "The sketch you want to close"},
@@ -1679,7 +1667,6 @@ pub async fn arc(exec_state: &mut ExecState, args: Args) -> Result<KclValue, Kcl
 /// ```
 #[stdlib {
     name = "arc",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?" },
@@ -1922,7 +1909,6 @@ pub async fn tangential_arc(exec_state: &mut ExecState, args: Args) -> Result<Kc
 /// ```
 #[stdlib {
     name = "tangentialArc",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
@@ -2168,12 +2154,27 @@ async fn inner_tangential_arc_to_point(
 pub async fn bezier_curve(exec_state: &mut ExecState, args: Args) -> Result<KclValue, KclError> {
     let sketch =
         args.get_unlabeled_kw_arg_typed("sketch", &RuntimeType::Primitive(PrimitiveType::Sketch), exec_state)?;
-    let end: [TyF64; 2] = args.get_kw_arg_typed("end", &RuntimeType::point2d(), exec_state)?;
+    let control1 = args.get_kw_arg_opt_typed("control1", &RuntimeType::point2d(), exec_state)?;
-    let control1: [TyF64; 2] = args.get_kw_arg_typed("control1", &RuntimeType::point2d(), exec_state)?;
+    let control2 = args.get_kw_arg_opt_typed("control2", &RuntimeType::point2d(), exec_state)?;
-    let control2: [TyF64; 2] = args.get_kw_arg_typed("control2", &RuntimeType::point2d(), exec_state)?;
+    let end = args.get_kw_arg_opt_typed("end", &RuntimeType::point2d(), exec_state)?;
+    let control1_absolute = args.get_kw_arg_opt_typed("control1Absolute", &RuntimeType::point2d(), exec_state)?;
+    let control2_absolute = args.get_kw_arg_opt_typed("control2Absolute", &RuntimeType::point2d(), exec_state)?;
+    let end_absolute = args.get_kw_arg_opt_typed("endAbsolute", &RuntimeType::point2d(), exec_state)?;
     let tag = args.get_kw_arg_opt("tag")?;
 
-    let new_sketch = inner_bezier_curve(sketch, control1, control2, end, tag, exec_state, args).await?;
+    let new_sketch = inner_bezier_curve(
+        sketch,
+        control1,
+        control2,
+        end,
+        control1_absolute,
+        control2_absolute,
+        end_absolute,
+        tag,
+        exec_state,
+        args,
+    )
+    .await?;
     Ok(KclValue::Sketch {
         value: Box::new(new_sketch),
     })
@@ -2184,6 +2185,7 @@ pub async fn bezier_curve(exec_state: &mut ExecState, args: Args) -> Result<KclV
 /// shape.
 ///
 /// ```no_run
+/// // Example using relative control points.
 /// exampleSketch = startSketchOn(XZ)
 ///   |> startProfile(at = [0, 0])
 ///   |> line(end = [0, 10])
@@ -2197,52 +2199,101 @@ pub async fn bezier_curve(exec_state: &mut ExecState, args: Args) -> Result<KclV
 ///
 /// example = extrude(exampleSketch, length = 10)
 /// ```
+/// ```no_run
+/// // Example using absolute control points.
+/// startSketchOn(XY)
+///   |> startProfile(at = [300, 300])
+///   |> bezierCurve(control1Absolute = [600, 300], control2Absolute = [-300, -100], endAbsolute = [600, 600])
+///   |> close()
+///   |> extrude(length = 10)
+/// ```
 #[stdlib {
     name = "bezierCurve",
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?"},
-        end = { docs = "How far away (along the X and Y axes) should this line go?" },
         control1 = { docs = "First control point for the cubic" },
         control2 = { docs = "Second control point for the cubic" },
+        end = { docs = "How far away (along the X and Y axes) should this line go?" },
+        control1_absolute = { docs = "First control point for the cubic. Absolute point." },
+        control2_absolute = { docs = "Second control point for the cubic. Absolute point." },
+        end_absolute = { docs = "Coordinate on the plane at which this line should end." },
         tag = { docs = "Create a new tag which refers to this line"},
     },
     tags = ["sketch"]
 }]
+#[allow(clippy::too_many_arguments)]
 async fn inner_bezier_curve(
     sketch: Sketch,
-    control1: [TyF64; 2],
+    control1: Option<[TyF64; 2]>,
-    control2: [TyF64; 2],
+    control2: Option<[TyF64; 2]>,
-    end: [TyF64; 2],
+    end: Option<[TyF64; 2]>,
+    control1_absolute: Option<[TyF64; 2]>,
+    control2_absolute: Option<[TyF64; 2]>,
+    end_absolute: Option<[TyF64; 2]>,
     tag: Option<TagNode>,
     exec_state: &mut ExecState,
     args: Args,
 ) -> Result<Sketch, KclError> {
     let from = sketch.current_pen_position()?;
-
-    let relative = true;
-    let delta = end.clone();
-    let to = [
-        from.x + end[0].to_length_units(from.units),
-        from.y + end[1].to_length_units(from.units),
-    ];
-
     let id = exec_state.next_uuid();
 
-    args.batch_modeling_cmd(
+    let to = match (
-        id,
+        control1,
-        ModelingCmd::from(mcmd::ExtendPath {
+        control2,
-            path: sketch.id.into(),
+        end,
-            segment: PathSegment::Bezier {
+        control1_absolute,
-                control1: KPoint2d::from(point_to_mm(control1)).with_z(0.0).map(LengthUnit),
+        control2_absolute,
-                control2: KPoint2d::from(point_to_mm(control2)).with_z(0.0).map(LengthUnit),
+        end_absolute,
-                end: KPoint2d::from(point_to_mm(delta)).with_z(0.0).map(LengthUnit),
+    ) {
-                relative,
+        // Relative
-            },
+        (Some(control1), Some(control2), Some(end), None, None, None) => {
-        }),
+            let delta = end.clone();
-    )
+            let to = [
-    .await?;
+                from.x + end[0].to_length_units(from.units),
+                from.y + end[1].to_length_units(from.units),
+            ];
+
+            args.batch_modeling_cmd(
+                id,
+                ModelingCmd::from(mcmd::ExtendPath {
+                    path: sketch.id.into(),
+                    segment: PathSegment::Bezier {
+                        control1: KPoint2d::from(point_to_mm(control1)).with_z(0.0).map(LengthUnit),
+                        control2: KPoint2d::from(point_to_mm(control2)).with_z(0.0).map(LengthUnit),
+                        end: KPoint2d::from(point_to_mm(delta)).with_z(0.0).map(LengthUnit),
+                        relative: true,
+                    },
+                }),
+            )
+            .await?;
+            to
+        }
+        // Absolute
+        (None, None, None, Some(control1), Some(control2), Some(end)) => {
+            let to = [end[0].to_length_units(from.units), end[1].to_length_units(from.units)];
+            args.batch_modeling_cmd(
+                id,
+                ModelingCmd::from(mcmd::ExtendPath {
+                    path: sketch.id.into(),
+                    segment: PathSegment::Bezier {
+                        control1: KPoint2d::from(point_to_mm(control1)).with_z(0.0).map(LengthUnit),
+                        control2: KPoint2d::from(point_to_mm(control2)).with_z(0.0).map(LengthUnit),
+                        end: KPoint2d::from(point_to_mm(end)).with_z(0.0).map(LengthUnit),
+                        relative: false,
+                    },
+                }),
+            )
+            .await?;
+            to
+        }
+        _ => {
+            return Err(KclError::Semantic(KclErrorDetails::new(
+                "You must either give `control1`, `control2` and `end`, or `control1Absolute`, `control2Absolute` and `endAbsolute`.".to_owned(),
+                vec![args.source_range],
+            )));
+        }
+    };
 
     let current_path = Path::ToPoint {
         base: BasePath {
@@ -2321,7 +2372,6 @@ pub async fn subtract_2d(exec_state: &mut ExecState, args: Args) -> Result<KclVa
 #[stdlib {
     name = "subtract2d",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketch = { docs = "Which sketch should this path be added to?" },

rust/kcl-lib/src/std/sweep.rs

@@ -160,7 +160,6 @@ pub async fn sweep(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 #[stdlib {
     name = "sweep",
     feature_tree_operation = true,
-    keywords = true,
     unlabeled_first = true,
     args = {
         sketches = { docs = "The sketch or set of sketches that should be swept in space" },

rust/kcl-lib/src/std/transform.rs

@@ -147,7 +147,6 @@ pub async fn scale(exec_state: &mut ExecState, args: Args) -> Result<KclValue, K
 #[stdlib {
     name = "scale",
     feature_tree_operation = false,
-    keywords = true,
     unlabeled_first = true,
     args = {
         objects = {docs = "The solid, sketch, or set of solids or sketches to scale."},
@@ -378,7 +377,6 @@ pub async fn translate(exec_state: &mut ExecState, args: Args) -> Result<KclValu
 #[stdlib {
     name = "translate",
     feature_tree_operation = false,
-    keywords = true,
     unlabeled_first = true,
     args = {
         objects = {docs = "The solid, sketch, or set of solids or sketches to move."},
@@ -782,7 +780,6 @@ pub async fn rotate(exec_state: &mut ExecState, args: Args) -> Result<KclValue,
 #[stdlib {
     name = "rotate",
     feature_tree_operation = false,
-    keywords = true,
     unlabeled_first = true,
     args = {
         objects = {docs = "The solid, sketch, or set of solids or sketches to rotate."},

rust/kcl-lib/src/unparser.rs

@@ -583,14 +583,16 @@ impl ArrayRangeExpression {
         let s1 = self.start_element.recast(options, 0, ExprContext::Other);
         let s2 = self.end_element.recast(options, 0, ExprContext::Other);
 
+        let range_op = if self.end_inclusive { ".." } else { "..<" };
+
         // Format these items into a one-line array. Put spaces around the `..` if either expression
         // is non-trivial. This is a bit arbitrary but people seem to like simple ranges to be formatted
         // tightly, but this is a misleading visual representation of the precedence if the range
         // components are compound expressions.
         if expr_is_trivial(&self.start_element) && expr_is_trivial(&self.end_element) {
-            format!("[{s1}..{s2}]")
+            format!("[{s1}{range_op}{s2}]")
         } else {
-            format!("[{s1} .. {s2}]")
+            format!("[{s1} {range_op} {s2}]")
         }
 
         // Assume a range expression fits on one line.
@@ -2797,4 +2799,12 @@ yo = 'bing'
         let recasted = ast.recast(&FormatOptions::new(), 0);
         assert_eq!(recasted, code);
     }
+
+    #[test]
+    fn array_range_end_exclusive() {
+        let code = "myArray = [0..<4]\n";
+        let ast = crate::parsing::top_level_parse(code).unwrap();
+        let recasted = ast.recast(&FormatOptions::new(), 0);
+        assert_eq!(recasted, code);
+    }
 }

rust/kcl-lib/std/appearance.kcl

@@ -0,0 +1,64 @@
+/// Build a color from its red, green and blue components.
+/// These must be between 0 and 255.
+///
+/// ```
+/// startSketchOn(-XZ)
+///   |> circle(center = [0, 0], radius = 10)
+///   |> extrude(length = 4)
+///   |> appearance(color = appearance::hexString([50, 160, 160]))
+/// ```
+/// ```
+/// sideLen = 30
+/// n = 10
+/// 
+/// // The cubes become more green and less blue with each instance.
+/// fn cube(i, center) {
+///   g = 255 / n * i
+///   b = 255 / n * (n - i)
+///   return startSketchOn(XY)
+///     |> polygon(radius = sideLen / 2, numSides = 4, center = [center, 0])
+///     |> extrude(length = sideLen)
+///     |> appearance(color = appearance::hexString([0, g, b]), metalness = 80, roughness = 20)
+/// }
+/// 
+/// // Create n cubes, shifting each one over in a line.
+/// map(
+///   [0..n],
+///   f = fn(@i) {
+///     return cube(i, center = sideLen * i * 1.5)
+///   },
+/// )
+/// ```
+/// ```
+/// sideLen = 30
+/// n = 6
+/// 
+/// fn cube(offset, i, red) {
+///   x = floor(i / n)
+///   y = rem(i, divisor = n)
+///   g = 255 / n * x
+///   b = 255 / n * y
+///   return startSketchOn(offsetPlane(XZ, offset))
+///     |> circle(diameter = sideLen, center = [sideLen * x * 1.5, sideLen * y * 1.5])
+///     |> extrude(length = sideLen)
+///     |> appearance(color = appearance::hexString([red, g, b]), metalness = 80, roughness = 40)
+/// }
+/// 
+/// fn grid(offset, red) {
+///   return map(
+///     [0 ..< n * n],
+///     f = fn(@i) {
+///       return cube(offset, i, red)
+///     },
+///   )
+/// }
+/// 
+/// grid(offset = 0, red = 0)
+/// ```
+///
+@(impl = std_rust)
+export fn hexString(
+  /// The red, blue and green components of the color.
+  /// Must be between 0 and 255.
+  @rgb: [number(_); 3],
+): string {}

rust/kcl-lib/std/prelude.kcl

@@ -22,6 +22,7 @@ export import * from "std::solid"
 export import * from "std::transform"
 export import "std::turns"
 export import "std::sweep"
+export import "std::appearance"
 
 /// An abstract 3d plane aligned with the X and Y axes. Its normal is the positive Z axis.
 export XY = {

rust/kcl-lib/std/sketch.kcl

@@ -33,10 +33,12 @@ export fn circle(
   /// Sketch to extend, or plane or surface to sketch on.
   @sketch_or_surface: Sketch | Plane | Face,
   /// The center of the circle.
+  @(snippetArray = ["0", "0"])
   center: Point2d,
   /// The radius of the circle. Incompatible with `diameter`.
   radius?: number(Length),
   /// The diameter of the circle. Incompatible with `radius`.
+  @(include_in_snippet = true)
   diameter?: number(Length),
   /// Create a new tag which refers to this circle.
   tag?: tag,

rust/kcl-lib/tests/basic_fillet_cube_close_opposite/artifact_commands.snap

@@ -224,30 +224,16 @@ description: Artifact commands basic_fillet_cube_close_opposite.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 2.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/basic_fillet_cube_close_opposite/artifact_graph_flowchart.snap.md

@@ -39,8 +39,6 @@ flowchart LR
   22["SweepEdge Adjacent"]
   23["EdgeCut Fillet<br>[221, 281, 0]"]
     %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  24["EdgeCut Fillet<br>[221, 281, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
   1 --- 2
   2 --- 3
   2 --- 4
@@ -64,7 +62,7 @@ flowchart LR
   6 x--> 13
   6 --- 15
   6 --- 19
-  6 --- 24
+  6 --- 23
   8 --- 9
   8 --- 10
   8 --- 11
@@ -95,5 +93,4 @@ flowchart LR
   16 <--x 14
   17 <--x 14
   18 <--x 14
-  15 <--x 23
 ```

rust/kcl-lib/tests/basic_fillet_cube_end/artifact_commands.snap

@@ -224,30 +224,16 @@ description: Artifact commands basic_fillet_cube_end.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 2.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/basic_fillet_cube_end/artifact_graph_flowchart.snap.md

@@ -39,8 +39,6 @@ flowchart LR
   22["SweepEdge Adjacent"]
   23["EdgeCut Fillet<br>[209, 267, 0]"]
     %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  24["EdgeCut Fillet<br>[209, 267, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
   1 --- 2
   2 --- 3
   2 --- 4
@@ -52,7 +50,7 @@ flowchart LR
   3 x--> 13
   3 --- 18
   3 --- 22
-  3 --- 24
+  3 --- 23
   4 --- 10
   4 x--> 13
   4 --- 17
@@ -95,5 +93,4 @@ flowchart LR
   16 <--x 14
   17 <--x 14
   18 <--x 14
-  18 <--x 23
 ```

rust/kcl-lib/tests/basic_fillet_cube_start/artifact_commands.snap

@@ -224,30 +224,16 @@ description: Artifact commands basic_fillet_cube_start.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 2.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   }
 ]

rust/kcl-lib/tests/basic_fillet_cube_start/artifact_graph_flowchart.snap.md

@@ -39,8 +39,6 @@ flowchart LR
   22["SweepEdge Adjacent"]
   23["EdgeCut Fillet<br>[209, 251, 0]"]
     %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  24["EdgeCut Fillet<br>[209, 251, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
   1 --- 2
   2 --- 3
   2 --- 4
@@ -61,7 +59,6 @@ flowchart LR
   5 x--> 13
   5 --- 16
   5 --- 20
-  5 --- 24
   6 --- 11
   6 x--> 13
   6 --- 15

rust/kcl-lib/tests/fillet-and-shell/artifact_commands.snap

@@ -351,64 +351,20 @@ description: Artifact commands fillet-and-shell.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 1.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 1.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/fillet-and-shell/artifact_graph_flowchart.snap.md

@@ -174,12 +174,6 @@ flowchart LR
   85["SweepEdge Adjacent"]
   86["EdgeCut Fillet<br>[1068, 1274, 0]"]
     %% [ProgramBodyItem { index: 17 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  87["EdgeCut Fillet<br>[1068, 1274, 0]"]
-    %% [ProgramBodyItem { index: 17 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  88["EdgeCut Fillet<br>[1068, 1274, 0]"]
-    %% [ProgramBodyItem { index: 17 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  89["EdgeCut Fillet<br>[1068, 1274, 0]"]
-    %% [ProgramBodyItem { index: 17 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
   1 --- 7
   2 --- 8
   3 --- 10
@@ -319,8 +313,5 @@ flowchart LR
   74 <--x 69
   75 <--x 69
   76 <--x 69
-  81 <--x 89
+  81 <--x 86
-  82 <--x 87
-  83 <--x 88
-  84 <--x 86
 ```

rust/kcl-lib/tests/kcl_samples/80-20-rail/artifact_commands.snap

@@ -1515,268 +1515,44 @@ description: Artifact commands 80-20-rail.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 1.5239999999999998,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
+        "[uuid]",
-    "cmdId": "[uuid]",
+        "[uuid]",
-    "range": [],
+        "[uuid]",
-    "command": {
+        "[uuid]",
-      "type": "solid3d_fillet_edge",
+        "[uuid]",
-      "object_id": "[uuid]",
+        "[uuid]",
-      "edge_id": null,
+        "[uuid]",
-      "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
-      ],
+      ]
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 1.5239999999999998,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {
@@ -1947,268 +1723,44 @@ description: Artifact commands 80-20-rail.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 0.7619999999999999,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
+        "[uuid]",
-    "cmdId": "[uuid]",
+        "[uuid]",
-    "range": [],
+        "[uuid]",
-    "command": {
+        "[uuid]",
-      "type": "solid3d_fillet_edge",
+        "[uuid]",
-      "object_id": "[uuid]",
+        "[uuid]",
-      "edge_id": null,
+        "[uuid]",
-      "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
-      ],
+      ]
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 0.7619999999999999,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/kcl_samples/80-20-rail/artifact_graph_flowchart.snap.md

@@ -408,67 +408,7 @@ flowchart LR
   266["SweepEdge Adjacent"]
   267["EdgeCut Fillet<br>[5122, 5827, 0]"]
     %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  268["EdgeCut Fillet<br>[5122, 5827, 0]"]
+  268["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  269["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  270["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  271["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  272["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  273["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  274["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  275["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  276["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  277["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  278["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  279["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  280["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  281["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  282["EdgeCut Fillet<br>[5122, 5827, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 69 }]
-  283["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  284["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  285["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  286["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  287["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  288["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  289["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  290["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  291["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  292["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  293["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  294["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  295["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  296["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  297["EdgeCut Fillet<br>[5835, 6539, 0]"]
-    %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
-  298["EdgeCut Fillet<br>[5835, 6539, 0]"]
     %% [ProgramBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 70 }]
   1 --- 2
   1 --- 3
@@ -1247,36 +1187,6 @@ flowchart LR
   200 <--x 138
   201 <--x 138
   202 <--x 138
-  207 <--x 286
+  207 <--x 268
-  208 <--x 292
+  209 <--x 267
-  209 <--x 278
-  210 <--x 280
-  211 <--x 273
-  212 <--x 268
-  213 <--x 285
-  214 <--x 294
-  223 <--x 289
-  224 <--x 287
-  225 <--x 272
-  226 <--x 274
-  227 <--x 270
-  228 <--x 271
-  229 <--x 290
-  230 <--x 291
-  239 <--x 284
-  240 <--x 297
-  241 <--x 282
-  242 <--x 281
-  243 <--x 267
-  244 <--x 279
-  245 <--x 283
-  246 <--x 293
-  255 <--x 298
-  256 <--x 295
-  257 <--x 276
-  258 <--x 275
-  259 <--x 269
-  260 <--x 277
-  261 <--x 288
-  262 <--x 296
 ```

rust/kcl-lib/tests/kcl_samples/axial-fan/artifact_commands.snap

@@ -2385,132 +2385,28 @@ description: Artifact commands axial-fan.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 7.5,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
+        "[uuid]",
-    "cmdId": "[uuid]",
+        "[uuid]",
-    "range": [],
+        "[uuid]",
-    "command": {
+        "[uuid]",
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 7.5,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {
@@ -2802,30 +2698,16 @@ description: Artifact commands axial-fan.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 2.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/kcl_samples/axial-fan/artifact_graph_flowchart.snap.md

@@ -370,15 +370,7 @@ flowchart LR
   265["SweepEdge Adjacent"]
   266["SweepEdge Adjacent"]
   267["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  268["EdgeCut Fillet<br>[5131, 5642, 1]"]
+  268["EdgeCut Fillet<br>[412, 470, 3]"]
-  269["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  270["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  271["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  272["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  273["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  274["EdgeCut Fillet<br>[5131, 5642, 1]"]
-  275["EdgeCut Fillet<br>[412, 470, 3]"]
-  276["EdgeCut Fillet<br>[412, 470, 3]"]
   1 --- 8
   1 --- 9
   1 --- 10
@@ -619,7 +611,6 @@ flowchart LR
   71 x--> 178
   71 --- 220
   71 --- 264
-  71 --- 276
   72 --- 149
   72 x--> 181
   72 --- 194
@@ -661,19 +652,19 @@ flowchart LR
   84 --- 144
   84 --- 237
   86 --- 168
-  86 x--> 189
+  86 x--> 188
   86 --- 212
   86 --- 256
   88 --- 169
-  88 x--> 189
+  88 x--> 188
   88 --- 213
   88 --- 257
   90 --- 167
-  90 x--> 189
+  90 x--> 188
   90 --- 214
   90 --- 258
   92 --- 170
-  92 x--> 189
+  92 x--> 188
   92 --- 215
   92 --- 259
   119 --- 133
@@ -955,17 +946,10 @@ flowchart LR
   218 <--x 186
   219 <--x 186
   194 <--x 187
-  212 <--x 188
+  212 <--x 189
-  213 <--x 188
+  213 <--x 189
-  214 <--x 188
+  214 <--x 189
-  215 <--x 188
+  215 <--x 189
-  220 <--x 275
+  220 <--x 268
-  223 <--x 270
+  223 <--x 267
-  224 <--x 274
-  225 <--x 273
-  226 <--x 267
-  260 <--x 271
-  261 <--x 268
-  262 <--x 269
-  263 <--x 272
 ```

rust/kcl-lib/tests/kcl_samples/bottle/artifact_graph_flowchart.snap.md

@@ -1,62 +1,156 @@
 ```mermaid
 flowchart LR
-  subgraph path4 [Path]
+  subgraph path3 [Path]
-    4["Path<br>[355, 396, 0]"]
+    3["Path<br>[355, 396, 0]"]
       %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-    6["Segment<br>[402, 433, 0]"]
+    5["Segment<br>[402, 433, 0]"]
       %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 2 }]
-    7["Segment<br>[439, 534, 0]"]
+    6["Segment<br>[439, 534, 0]"]
       %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 3 }]
-    8["Segment<br>[540, 562, 0]"]
+    7["Segment<br>[540, 562, 0]"]
       %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 4 }]
-    9["Segment<br>[592, 599, 0]"]
+    8["Segment<br>[568, 586, 0]"]
+      %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
+    9["Segment<br>[568, 586, 0]"]
+      %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
+    10["Segment<br>[568, 586, 0]"]
+      %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
+    11["Segment<br>[568, 586, 0]"]
+      %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
+    12["Segment<br>[568, 586, 0]"]
+      %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
+    13["Segment<br>[592, 599, 0]"]
       %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 6 }]
-    11[Solid2d]
+    15[Solid2d]
   end
-  subgraph path5 [Path]
+  subgraph path4 [Path]
-    5["Path<br>[756, 806, 0]"]
+    4["Path<br>[756, 806, 0]"]
       %% [ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-    10["Segment<br>[756, 806, 0]"]
+    14["Segment<br>[756, 806, 0]"]
       %% [ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-    12[Solid2d]
+    16[Solid2d]
   end
   1["Plane<br>[332, 349, 0]"]
     %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-  2["Plane<br>[756, 806, 0]"]
+  2["StartSketchOnFace<br>[713, 750, 0]"]
-    %% [ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-  3["StartSketchOnFace<br>[713, 750, 0]"]
     %% [ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-  13["Sweep Extrusion<br>[605, 647, 0]"]
+  17["Sweep Extrusion<br>[605, 647, 0]"]
     %% [ProgramBodyItem { index: 6 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-  14["Sweep Extrusion<br>[812, 839, 0]"]
+  18["Sweep Extrusion<br>[812, 839, 0]"]
     %% [ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 2 }]
-  15[Wall]
+  19[Wall]
     %% face_code_ref=Missing NodePath
-  16["Cap End"]
+  20[Wall]
     %% face_code_ref=Missing NodePath
-  17["SweepEdge Opposite"]
+  21[Wall]
-  18["SweepEdge Adjacent"]
+    %% face_code_ref=Missing NodePath
-  1 --- 4
+  22[Wall]
-  2 <--x 3
+    %% face_code_ref=Missing NodePath
-  2 --- 5
+  23[Wall]
-  10 <--x 2
+    %% face_code_ref=Missing NodePath
-  4 --- 6
+  24[Wall]
-  4 --- 7
+    %% face_code_ref=Missing NodePath
-  4 --- 8
+  25["Cap Start"]
-  4 --- 9
+    %% face_code_ref=Missing NodePath
-  4 --- 11
+  26["Cap End"]
-  4 ---- 13
+    %% face_code_ref=Missing NodePath
-  5 --- 10
+  27["Cap End"]
-  5 --- 12
+    %% face_code_ref=[ProgramBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-  5 ---- 14
+  28["SweepEdge Opposite"]
-  10 --- 15
+  29["SweepEdge Opposite"]
-  10 --- 17
+  30["SweepEdge Opposite"]
-  10 --- 18
+  31["SweepEdge Opposite"]
-  14 --- 15
+  32["SweepEdge Opposite"]
-  14 --- 16
+  33["SweepEdge Opposite"]
-  14 --- 17
+  34["SweepEdge Adjacent"]
-  14 --- 18
+  35["SweepEdge Adjacent"]
-  15 --- 17
+  36["SweepEdge Adjacent"]
-  15 --- 18
+  37["SweepEdge Adjacent"]
-  17 <--x 16
+  38["SweepEdge Adjacent"]
+  39["SweepEdge Adjacent"]
+  1 --- 3
+  27 x--> 2
+  3 --- 5
+  3 --- 6
+  3 --- 7
+  3 --- 8
+  3 --- 9
+  3 --- 10
+  3 --- 11
+  3 --- 12
+  3 --- 13
+  3 --- 15
+  3 ---- 17
+  4 --- 14
+  4 --- 16
+  4 ---- 18
+  27 --- 4
+  8 --- 20
+  8 x--> 25
+  8 --- 33
+  8 --- 39
+  9 --- 21
+  9 x--> 25
+  9 --- 31
+  9 --- 37
+  10 --- 22
+  10 x--> 25
+  10 --- 32
+  10 --- 38
+  11 --- 23
+  11 x--> 25
+  11 --- 30
+  11 --- 36
+  12 --- 24
+  12 x--> 25
+  12 --- 29
+  12 --- 35
+  14 --- 19
+  14 x--> 27
+  14 --- 28
+  14 --- 34
+  17 --- 20
+  17 --- 21
+  17 --- 22
+  17 --- 23
+  17 --- 24
+  17 --- 25
+  17 --- 27
+  17 --- 29
+  17 --- 30
+  17 --- 31
+  17 --- 32
+  17 --- 33
+  17 --- 35
+  17 --- 36
+  17 --- 37
+  17 --- 38
+  17 --- 39
+  18 --- 19
+  18 --- 26
+  18 --- 28
+  18 --- 34
+  19 --- 28
+  19 --- 34
+  20 --- 33
+  35 <--x 20
+  20 --- 39
+  21 --- 31
+  21 --- 37
+  38 <--x 21
+  22 --- 32
+  22 --- 38
+  39 <--x 22
+  23 --- 30
+  23 --- 36
+  37 <--x 23
+  24 --- 29
+  24 --- 35
+  36 <--x 24
+  28 <--x 26
+  29 <--x 27
+  30 <--x 27
+  31 <--x 27
+  32 <--x 27
+  33 <--x 27
 ```

rust/kcl-lib/tests/kcl_samples/bracket/artifact_commands.snap

@@ -969,64 +969,20 @@ description: Artifact commands bracket.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 12.7,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 12.7,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 12.7,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 12.7,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/kcl_samples/bracket/artifact_graph_flowchart.snap.md

@@ -95,12 +95,6 @@ flowchart LR
     %% [ProgramBodyItem { index: 24 }, ExpressionStatementExpr]
   54["EdgeCut Fillet<br>[3780, 3922, 0]"]
     %% [ProgramBodyItem { index: 25 }, ExpressionStatementExpr]
-  55["EdgeCut Fillet<br>[3780, 3922, 0]"]
-    %% [ProgramBodyItem { index: 25 }, ExpressionStatementExpr]
-  56["EdgeCut Fillet<br>[3780, 3922, 0]"]
-    %% [ProgramBodyItem { index: 25 }, ExpressionStatementExpr]
-  57["EdgeCut Fillet<br>[3780, 3922, 0]"]
-    %% [ProgramBodyItem { index: 25 }, ExpressionStatementExpr]
   1 --- 4
   32 x--> 2
   33 x--> 3
@@ -129,7 +123,7 @@ flowchart LR
   8 x--> 34
   8 --- 39
   8 --- 47
-  8 --- 56
+  8 --- 54
   9 --- 32
   9 x--> 34
   9 --- 40
@@ -142,7 +136,6 @@ flowchart LR
   11 x--> 34
   11 --- 42
   11 --- 50
-  11 --- 54
   12 --- 28
   12 x--> 34
   12 --- 43
@@ -211,8 +204,6 @@ flowchart LR
   41 <--x 35
   42 <--x 35
   43 <--x 35
-  39 <--x 57
-  42 <--x 55
   48 <--x 52
   51 <--x 53
 ```

rust/kcl-lib/tests/kcl_samples/brake-rotor/artifact_commands.snap

@@ -2672,64 +2672,20 @@ description: Artifact commands brake-rotor.kcl
       "object_id": "[uuid]",
       "edge_id": null,
       "edge_ids": [
+        "[uuid]",
+        "[uuid]",
+        "[uuid]",
         "[uuid]"
       ],
       "radius": 2.0,
       "tolerance": 0.0000001,
       "cut_type": "fillet",
       "strategy": "automatic",
-      "extra_face_ids": []
+      "extra_face_ids": [
-    }
+        "[uuid]",
-  },
+        "[uuid]",
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
         "[uuid]"
-      ],
+      ]
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
-    }
-  },
-  {
-    "cmdId": "[uuid]",
-    "range": [],
-    "command": {
-      "type": "solid3d_fillet_edge",
-      "object_id": "[uuid]",
-      "edge_id": null,
-      "edge_ids": [
-        "[uuid]"
-      ],
-      "radius": 2.0,
-      "tolerance": 0.0000001,
-      "cut_type": "fillet",
-      "strategy": "automatic",
-      "extra_face_ids": []
     }
   },
   {

rust/kcl-lib/tests/kcl_samples/brake-rotor/artifact_graph_flowchart.snap.md

@@ -1,151 +1,151 @@
 ```mermaid
 flowchart LR
   subgraph path8 [Path]
-    8["Path<br>[1124, 1197, 0]"]
+    8["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    26["Segment<br>[1124, 1197, 0]"]
+    26["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     48[Solid2d]
   end
   subgraph path9 [Path]
-    9["Path<br>[1124, 1197, 0]"]
+    9["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    24["Segment<br>[1124, 1197, 0]"]
+    24["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     49[Solid2d]
   end
   subgraph path10 [Path]
-    10["Path<br>[1124, 1197, 0]"]
+    10["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    21["Segment<br>[1124, 1197, 0]"]
+    21["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     51[Solid2d]
   end
   subgraph path11 [Path]
-    11["Path<br>[1124, 1197, 0]"]
+    11["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    25["Segment<br>[1124, 1197, 0]"]
+    25["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     52[Solid2d]
   end
   subgraph path12 [Path]
-    12["Path<br>[1124, 1197, 0]"]
+    12["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    23["Segment<br>[1124, 1197, 0]"]
+    23["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     53[Solid2d]
   end
   subgraph path13 [Path]
-    13["Path<br>[1124, 1197, 0]"]
+    13["Path<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-    22["Segment<br>[1124, 1197, 0]"]
+    22["Segment<br>[1139, 1212, 0]"]
       %% [ProgramBodyItem { index: 20 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 8 }, VariableDeclarationDeclaration, VariableDeclarationInit]
     57[Solid2d]
   end
   subgraph path14 [Path]
-    14["Path<br>[1402, 1462, 0]"]
+    14["Path<br>[1417, 1477, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-    27["Segment<br>[1402, 1462, 0]"]
+    27["Segment<br>[1417, 1477, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
     46[Solid2d]
   end
   subgraph path15 [Path]
-    15["Path<br>[1402, 1462, 0]"]
+    15["Path<br>[1417, 1477, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-    28["Segment<br>[1402, 1462, 0]"]
+    28["Segment<br>[1417, 1477, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
     54[Solid2d]
   end
   subgraph path16 [Path]
-    16["Path<br>[1488, 1572, 0]"]
+    16["Path<br>[1503, 1587, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }, CallKwArg { index: 0 }]
-    29["Segment<br>[1488, 1572, 0]"]
+    29["Segment<br>[1503, 1587, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }, CallKwArg { index: 0 }]
     55[Solid2d]
   end
   subgraph path17 [Path]
-    17["Path<br>[1488, 1572, 0]"]
+    17["Path<br>[1503, 1587, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }, CallKwArg { index: 0 }]
-    30["Segment<br>[1488, 1572, 0]"]
+    30["Segment<br>[1503, 1587, 0]"]
       %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 1 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }, CallKwArg { index: 0 }]
     58[Solid2d]
   end
   subgraph path18 [Path]
-    18["Path<br>[2526, 2576, 0]"]
+    18["Path<br>[2541, 2591, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-    31["Segment<br>[2582, 2648, 0]"]
+    31["Segment<br>[2597, 2663, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-    32["Segment<br>[2654, 2748, 0]"]
+    32["Segment<br>[2669, 2763, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 2 }]
-    33["Segment<br>[2754, 2856, 0]"]
+    33["Segment<br>[2769, 2871, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 3 }]
-    34["Segment<br>[2862, 2932, 0]"]
+    34["Segment<br>[2877, 2947, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 4 }]
-    35["Segment<br>[2938, 2945, 0]"]
+    35["Segment<br>[2953, 2960, 0]"]
       %% [ProgramBodyItem { index: 25 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
     47[Solid2d]
   end
   subgraph path19 [Path]
-    19["Path<br>[4126, 4264, 0]"]
+    19["Path<br>[4141, 4279, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-    36["Segment<br>[4270, 4369, 0]"]
+    36["Segment<br>[4285, 4384, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-    37["Segment<br>[4375, 4423, 0]"]
+    37["Segment<br>[4390, 4438, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 2 }]
-    38["Segment<br>[4429, 4465, 0]"]
+    38["Segment<br>[4444, 4480, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 3 }]
-    39["Segment<br>[4471, 4493, 0]"]
+    39["Segment<br>[4486, 4508, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 4 }]
-    40["Segment<br>[4499, 4522, 0]"]
+    40["Segment<br>[4514, 4537, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 5 }]
-    41["Segment<br>[4528, 4578, 0]"]
+    41["Segment<br>[4543, 4593, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 6 }]
-    42["Segment<br>[4584, 4603, 0]"]
+    42["Segment<br>[4599, 4618, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 7 }]
-    43["Segment<br>[4628, 4668, 0]"]
+    43["Segment<br>[4643, 4683, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 8 }]
-    44["Segment<br>[4674, 4682, 0]"]
+    44["Segment<br>[4689, 4697, 0]"]
       %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 9 }]
     56[Solid2d]
   end
   subgraph path20 [Path]
-    20["Path<br>[4796, 4874, 0]"]
+    20["Path<br>[4811, 4889, 0]"]
       %% [ProgramBodyItem { index: 39 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-    45["Segment<br>[4796, 4874, 0]"]
+    45["Segment<br>[4811, 4889, 0]"]
       %% [ProgramBodyItem { index: 39 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
     50[Solid2d]
   end
-  1["Plane<br>[1365, 1385, 0]"]
+  1["Plane<br>[1380, 1400, 0]"]
     %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  2["Plane<br>[2438, 2473, 0]"]
+  2["Plane<br>[2453, 2488, 0]"]
     %% [ProgramBodyItem { index: 23 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  3["Plane<br>[3498, 3541, 0]"]
+  3["Plane<br>[3513, 3556, 0]"]
     %% [ProgramBodyItem { index: 28 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  4["Plane<br>[4092, 4110, 0]"]
+  4["Plane<br>[4107, 4125, 0]"]
     %% [ProgramBodyItem { index: 36 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  5["StartSketchOnPlane<br>[1365, 1385, 0]"]
+  5["StartSketchOnPlane<br>[1380, 1400, 0]"]
     %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 0 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  6["StartSketchOnPlane<br>[2487, 2511, 0]"]
+  6["StartSketchOnPlane<br>[2502, 2526, 0]"]
     %% [ProgramBodyItem { index: 24 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  7["StartSketchOnFace<br>[4740, 4781, 0]"]
+  7["StartSketchOnFace<br>[4755, 4796, 0]"]
     %% [ProgramBodyItem { index: 38 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  59["Sweep Extrusion<br>[2053, 2098, 0]"]
+  59["Sweep Extrusion<br>[2068, 2113, 0]"]
     %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  60["Sweep Extrusion<br>[2053, 2098, 0]"]
+  60["Sweep Extrusion<br>[2068, 2113, 0]"]
     %% [ProgramBodyItem { index: 21 }, VariableDeclarationDeclaration, VariableDeclarationInit, FunctionExpressionBody, FunctionExpressionBodyItem { index: 7 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  61["Sweep Extrusion<br>[2957, 2993, 0]"]
+  61["Sweep Extrusion<br>[2972, 3008, 0]"]
     %% [ProgramBodyItem { index: 26 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 0 }]
-  62["Sweep Revolve<br>[4688, 4705, 0]"]
+  62["Sweep Revolve<br>[4703, 4720, 0]"]
     %% [ProgramBodyItem { index: 37 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 10 }]
-  63["Sweep Extrusion<br>[5082, 5137, 0]"]
+  63["Sweep Extrusion<br>[5097, 5152, 0]"]
     %% [ProgramBodyItem { index: 41 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  64["Sweep Extrusion<br>[5082, 5137, 0]"]
+  64["Sweep Extrusion<br>[5097, 5152, 0]"]
     %% [ProgramBodyItem { index: 41 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  65["Sweep Extrusion<br>[5082, 5137, 0]"]
+  65["Sweep Extrusion<br>[5097, 5152, 0]"]
     %% [ProgramBodyItem { index: 41 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  66["Sweep Extrusion<br>[5082, 5137, 0]"]
+  66["Sweep Extrusion<br>[5097, 5152, 0]"]
     %% [ProgramBodyItem { index: 41 }, VariableDeclarationDeclaration, VariableDeclarationInit]
-  67["Sweep Extrusion<br>[5082, 5137, 0]"]
+  67["Sweep Extrusion<br>[5097, 5152, 0]"]
     %% [ProgramBodyItem { index: 41 }, VariableDeclarationDeclaration, VariableDeclarationInit]
   68[Wall]
     %% face_code_ref=Missing NodePath
@@ -213,13 +213,7 @@ flowchart LR
   109["SweepEdge Adjacent"]
   110["SweepEdge Adjacent"]
   111["SweepEdge Adjacent"]
-  112["EdgeCut Fillet<br>[2999, 3289, 0]"]
+  112["EdgeCut Fillet<br>[3014, 3304, 0]"]
-    %% [ProgramBodyItem { index: 26 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-  113["EdgeCut Fillet<br>[2999, 3289, 0]"]
-    %% [ProgramBodyItem { index: 26 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-  114["EdgeCut Fillet<br>[2999, 3289, 0]"]
-    %% [ProgramBodyItem { index: 26 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
-  115["EdgeCut Fillet<br>[2999, 3289, 0]"]
     %% [ProgramBodyItem { index: 26 }, VariableDeclarationDeclaration, VariableDeclarationInit, PipeBodyItem { index: 1 }]
   1 --- 8
   1 --- 9
@@ -420,8 +414,5 @@ flowchart LR
   94 <--x 87
   90 <--x 88
   96 <--x 89
-  98 <--x 113
+  98 <--x 112
-  99 <--x 112
-  100 <--x 115
-  101 <--x 114
 ```