Release kcl-test-server 0.1.14 (#4200)

* Split builds per os and per architecture to minimize artifacts size
Fixes #3920

* Add missing if case; Add nightly build updater support

* Fix linux x86_64

* Improve upload filtering

* Attempt to fix matrix

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest)

* Test release builds

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest)

* Clean up

* Clean up win arm64 builds

* Add temp fake-publish to check on artifacts

* A snapshot a day keeps the bugs away! 📷🐛 (OS: ubuntu-latest)

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest)

* A snapshot a day keeps the bugs away! 📷🐛 (OS: windows-latest)

* Trigger CI

* Fix win arm

* Clean up

* Remove forced release builds

---------

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

.github/workflows/build-test-publish-apps.yml

@@ -25,6 +25,7 @@ jobs:
     runs-on: ubuntu-22.04  # seperate job on Ubuntu for easy string manipulations (compared to Windows)
     outputs:
       version: ${{ steps.export_version.outputs.version }}
+      notes: ${{ steps.export_version.outputs.notes }}
     steps:
       - uses: actions/checkout@v4
 
@@ -53,22 +54,46 @@ jobs:
 
       # TODO: see if we need to inject updater nightly URL here https://dl.zoo.dev/releases/modeling-app/nightly/last_update.json
 
+      - name: Generate release notes
+        env:
+          NOTES: ${{ github.event_name == 'release' && github.event.release.body || format('Non-release build, commit {0}', github.sha) }}
+        run: |
+          echo "$NOTES" > release-notes.md
+          cat release-notes.md
+
       - uses: actions/upload-artifact@v3
         with:
           name: prepared-files
           path: |
             package.json
             src/wasm-lib/pkg/wasm_lib*
+            release-notes.md
 
       - id: export_version
         run: echo "version=`cat package.json | jq -r '.version'`" >> "$GITHUB_OUTPUT"
 
+      - name: Prepare electron-builder.yml file for nightly
+        if: ${{ github.event_name == 'schedule' }}
+        run: |
+          yq -i '.publish[0].url = "https://dl.zoo.dev/releases/modeling-app/nightly"' electron-builder.yml
+
+      - uses: actions/upload-artifact@v3
+        if: ${{ github.event_name == 'schedule' }}
+        with:
+          name: prepared-files-nightly
+          path: |
+            electron-builder.yml
+
+      - id: export_notes
+        run: echo "notes=`cat release-notes.md'`" >> "$GITHUB_OUTPUT"
+
       - name: Prepare electron-builder.yml file for updater test
         if: ${{ env.CUT_RELEASE_PR == 'true' }}
         run: |
-          yq -i '.publish[0].url = "https://dl.zoo.dev/releases/modeling-app/updater-test"' electron-builder.yml
+          yq -i '.publish[0].url = "https://dl.zoo.dev/releases/modeling-app/updater-test-release-notes"' electron-builder.yml
 
       - uses: actions/upload-artifact@v3
+        if: ${{ env.CUT_RELEASE_PR == 'true' }}
         with:
           name: prepared-files-updater-test
           path: |
@@ -80,7 +105,13 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-14, windows-2022, ubuntu-22.04]
+        include:
+          - os: macos-14
+            platform: mac
+          - os: windows-2022
+            platform: win
+          - os: ubuntu-22.04
+            platform: linux
     runs-on: ${{ matrix.os }}
     env:
       APPLE_ID: ${{ secrets.APPLE_ID }}
@@ -107,6 +138,17 @@ jobs:
           cp prepared-files/src/wasm-lib/pkg/wasm_lib_bg.wasm public
           mkdir src/wasm-lib/pkg
           cp prepared-files/src/wasm-lib/pkg/wasm_lib* src/wasm-lib/pkg
+          cp prepared-files/release-notes.md release-notes.md
+
+      - uses: actions/download-artifact@v3
+        if: ${{ github.event_name == 'schedule' }}
+        name: prepared-files-nightly
+
+      - name: Copy updated electron-builder.yml file for nightly build
+        if: ${{ github.event_name == 'schedule' }}
+        run: |
+          ls -R prepared-files-nightly
+          cp prepared-files-nightly/electron-builder.yml electron-builder.yml
 
       - name: Sync node version and setup cache
         uses: actions/setup-node@v4
@@ -152,9 +194,27 @@ jobs:
 
       - uses: actions/upload-artifact@v3
         with:
-          name: out-${{ matrix.os }}
+          name: out-arm64-${{ matrix.platform }}
+          # first two will pick both Zoo Modeling App-$VERSION-arm64-win.exe and Zoo Modeling App-$VERSION-win.exe
+          path: |
+            out/*-${{ env.VERSION_NO_V }}-win.*
+            out/*-${{ env.VERSION_NO_V }}-arm64-win.*
+            out/*-arm64-mac.*
+            out/*-arm64-linux.*
+
+      - uses: actions/upload-artifact@v3
+        with:
+          name: out-x64-${{ matrix.platform }}
+          path: |
+            out/*-x64-win.*
+            out/*-x64-mac.*
+            out/*-x86_64-linux.*
+
+      - uses: actions/upload-artifact@v3
+        if: ${{ env.CUT_RELEASE_PR == 'true' }}
+        with:
+          name: out-yml
           path: |
-            out/Zoo*.*
             out/latest*.yml
 
       # TODO: add the 'Build for Mac TestFlight (nightly)' stage back
@@ -176,10 +236,20 @@ jobs:
       - uses: actions/upload-artifact@v3
         if: ${{ env.CUT_RELEASE_PR == 'true' }}
         with:
-          name: updater-test-${{ matrix.os }}
+          name: updater-test-arm64-${{ matrix.platform }}
           path: |
-            out/Zoo*.*
-            out/latest*.yml
+            out/*-arm64-win.exe
+            out/*-arm64-mac.dmg
+            out/*-arm64-linux.AppImage
+
+      - uses: actions/upload-artifact@v3
+        if: ${{ env.CUT_RELEASE_PR == 'true' }}
+        with:
+          name: updater-test-x64-${{ matrix.platform }}
+          path: |
+            out/*-x64-win.exe
+            out/*-x64-mac.dmg
+            out/*-x86_64-linux.AppImage
 
 
   publish-apps-release:
@@ -192,7 +262,7 @@ jobs:
       VERSION_NO_V: ${{ needs.prepare-files.outputs.version }}
       VERSION: ${{ github.event_name == 'schedule' && needs.prepare-files.outputs.version || format('v{0}', needs.prepare-files.outputs.version) }}
       PUB_DATE: ${{ github.event_name == 'release' && github.event.release.created_at || github.event.repository.updated_at }}
-      NOTES: ${{ github.event_name == 'release' && github.event.release.body || format('Non-release build, commit {0}', github.sha) }}
+      NOTES: ${{ needs.prepare-files.outputs.notes }}
       BUCKET_DIR: ${{ github.event_name == 'schedule' && 'dl.kittycad.io/releases/modeling-app/nightly' || 'dl.kittycad.io/releases/modeling-app' }}
       WEBSITE_DIR: ${{ github.event_name == 'schedule' && 'dl.zoo.dev/releases/modeling-app/nightly' || 'dl.zoo.dev/releases/modeling-app' }}
       URL_CODED_NAME: ${{ github.event_name == 'schedule' && 'Zoo%20Modeling%20App%20%28Nightly%29' || 'Zoo%20Modeling%20App' }}
@@ -201,17 +271,37 @@ jobs:
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-windows-2022
+          name: out-arm64-win
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-macos-14
+          name: out-x64-win
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-ubuntu-22.04
+          name: out-arm64-mac
+          path: out
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: out-x64-mac
+          path: out
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: out-arm64-linux
+          path: out
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: out-x64-linux
+          path: out
+
+      - uses: actions/download-artifact@v3
+        with:
+          name: out-yml
           path: out
 
       - name: Generate the download static endpoint

.github/workflows/static-analysis.yml

@@ -37,10 +37,6 @@ jobs:
           node-version-file: '.nvmrc'
           cache: 'yarn'
       - run: yarn install
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: './src/wasm-lib'
-
       - run: yarn build:wasm
 
   yarn-tsc:
@@ -70,10 +66,6 @@ jobs:
           node-version-file: '.nvmrc'
           cache: 'yarn'
       - run: yarn install
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: './src/wasm-lib'
-
       - run: yarn lint
 
   python-codespell:
@@ -101,11 +93,6 @@ jobs:
           cache: 'yarn'
 
       - run: yarn install
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: './src/wasm-lib'
-
       - run: yarn build:wasm
 
       - run: yarn simpleserver:bg

README.md

@@ -57,7 +57,7 @@ yarn install
 followed by:
 
 ```
-yarn build:wasm-dev
+yarn build:wasm
 ```
 
 or if you have the gh cli installed
@@ -66,15 +66,15 @@ or if you have the gh cli installed
 ./get-latest-wasm-bundle.sh # this will download the latest main wasm bundle
 ```
 
-That will build the WASM binary and put in the `public` dir (though gitignored)
+That will build the WASM binary and put in the `public` dir (though gitignored).
 
-finally, to run the web app only, run:
+Finally, to run the web app only, run:
 
 ```
 yarn start
 ```
 
-If you're not an KittyCAD employee you won't be able to access the dev environment, you should copy everything from `.env.production` to `.env.development` to make it point to production instead, then when you navigate to `localhost:3000` the easiest way to sign in is to paste `localStorage.setItem('TOKEN_PERSIST_KEY', "your-token-from-https://zoo.dev/account/api-tokens")` replacing the with a real token from https://zoo.dev/account/api-tokens ofcourse, then navigate to localhost:3000 again. Note that navigating to localhost:3000/signin removes your token so you will need to set the token again.
+If you're not an KittyCAD employee you won't be able to access the dev environment, you should copy everything from `.env.production` to `.env.development` to make it point to production instead, then when you navigate to `localhost:3000` the easiest way to sign in is to paste `localStorage.setItem('TOKEN_PERSIST_KEY', "your-token-from-https://zoo.dev/account/api-tokens")` replacing the with a real token from https://zoo.dev/account/api-tokens of course, then navigate to localhost:3000 again. Note that navigating to `localhost:3000/signin` removes your token so you will need to set the token again.
 
 ### Development environment variables
 
@@ -91,13 +91,13 @@ Third-Party Cookies".
 
 ## Desktop
 
-To spin up the desktop app, `yarn install` and `yarn build:wasm-dev` need to have been done before hand then
+To spin up the desktop app, `yarn install` and `yarn build:wasm` need to have been done before hand then
 
 ```
-yarn electron:start
+yarn tron:start
 ```
 
-This will start the application and hot-reload on changed.
+This will start the application and hot-reload on changes.
 
 Devtools can be opened with the usual Cmd/Ctrl-Shift-I.
 
@@ -158,11 +158,29 @@ The PR may then serve as a place to discuss the human-readable changelog and ext
 
 #### 3. Manually test artifacts from the Cut Release PR
 
-The release builds can be find under the `artifact` zip, at the very bottom of the `ci` action page for each commit on this branch.
+##### Release builds
+
+The release builds can be found under the `out-{platform}` zip, at the very bottom of the `build-publish-apps` summary page for each commit on this branch.
 
 Manually test against this [list](https://github.com/KittyCAD/modeling-app/issues/3588) across Windows, MacOS, Linux and posting results as comments in the Cut Release PR.
 
-The other `ci` output in Cut Release PRs is `updater-test`, because we don't have a way to test this fully automated, we have a semi-automated process. Download updater-test zip file, install the app, run it, expect an updater prompt to a dummy v0.99.99, install it and check that the app comes back at that version (on both macOS and Windows).
+##### Updater-test builds
+
+The other `build-publish-apps` output in Cut Release PRs is `updater-test-{platform}`. As we don't have a way to test this fully automatically, we have a semi-automated process. For macOS, Windows, and Linux, download the corresponding updater-test artifact file, install the app, run it, expect an updater prompt to a dummy v0.255.255, install it and check that the app comes back at that version. 
+
+The only difference with these builds is that they point to a different update location on the release bucket, with this dummy v0.255.255 always available. This helps ensuring that the version we release will be able to update to the next one available.
+
+If the prompt doesn't show up, start the app in command line to grab the electron-updater logs. This is likely an issue with the current build that needs addressing (or the updater-test location in the storage bucket).
+```
+# Windows (PowerShell)
+& 'C:\Program Files\Zoo Modeling App\Zoo Modeling App.exe'
+
+# macOS
+/Applications/Zoo\ Modeling\ App.app/Contents/MacOS/Zoo\ Modeling\ App
+
+# Linux
+./Zoo Modeling App-{version}-{arch}-linux.AppImage
+```
 
 #### 4. Merge the Cut Release PR
 
@@ -334,7 +352,16 @@ Which will run our suite of [Vitest unit](https://vitest.dev/) and [React Testin
 
 ```bash
 cd src/wasm-lib
-cargo test
+KITTYCAD_API_TOKEN=XXX cargo test -- --test-threads=1
+```
+
+Where `XXX` is an API token from the production engine (NOT the dev environment).
+
+We recommend using [nextest](https://nexte.st/) to run the Rust tests (its faster and is used in CI). Once installed, run the tests using
+
+```
+cd src/wasm-lib
+KITTYCAD_API_TOKEN=XXX cargo run nextest
 ```
 
 ### Mapping CI CD jobs to local commands

docs/kcl/patternCircular2d.md

@@ -36,7 +36,7 @@ exampleSketch = startSketchOn('XZ')
   |> close(%)
   |> patternCircular2d({
        center: [0, 0],
-       repetitions: 12,
+       instances: 13,
        arcDegrees: 360,
        rotateDuplicates: true
      }, %)

docs/kcl/patternCircular3d.md

@@ -35,7 +35,7 @@ example = extrude(-5, exampleSketch)
   |> patternCircular3d({
        axis: [1, -1, 0],
        center: [10, -20, 0],
-       repetitions: 10,
+       instances: 11,
        arcDegrees: 360,
        rotateDuplicates: true
      }, %)

docs/kcl/patternLinear2d.md

@@ -32,7 +32,7 @@ exampleSketch = startSketchOn('XZ')
   |> circle({ center: [0, 0], radius: 1 }, %)
   |> patternLinear2d({
        axis: [1, 0],
-       repetitions: 6,
+       instances: 7,
        distance: 4
      }, %)
 

docs/kcl/patternLinear3d.md

@@ -38,7 +38,7 @@ exampleSketch = startSketchOn('XZ')
 example = extrude(1, exampleSketch)
   |> patternLinear3d({
        axis: [1, 0, 1],
-       repetitions: 6,
+       instances: 7,
        distance: 6
      }, %)
 ```

docs/kcl/reduce.md

@@ -18,12 +18,12 @@ reduce(array: [KclValue], start: KclValue, reduce_fn: FunctionParam) -> KclValue
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `array` | [`[KclValue]`](/docs/kcl/types/KclValue) |  | Yes |
-| `start` | [`KclValue`](/docs/kcl/types/KclValue) | A memory item. | Yes |
+| `start` | [`KclValue`](/docs/kcl/types/KclValue) | Any KCL value. | Yes |
 | `reduce_fn` | `FunctionParam` |  | Yes |
 
 ### Returns
 
-[`KclValue`](/docs/kcl/types/KclValue) - A memory item.
+[`KclValue`](/docs/kcl/types/KclValue) - Any KCL value.
 
 
 ### Examples
@@ -32,7 +32,7 @@ reduce(array: [KclValue], start: KclValue, reduce_fn: FunctionParam) -> KclValue
 fn decagon = (radius) => {
   step = 1 / 10 * tau()
   sketch001 = startSketchAt([cos(0) * radius, sin(0) * radius])
-  return reduce([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], sketch001, (i, sg) => {
+  return reduce([1..10], sketch001, (i, sg) => {
   x = cos(step * i) * radius
   y = sin(step * i) * radius
   return lineTo([x, y], sg)

docs/kcl/types/BinaryOperator.md

@@ -82,6 +82,78 @@ Raise a number to a power.
 
 
 
+----
+Are two numbers equal?
+
+**enum:** `==`
+
+
+
+
+
+
+
+
+----
+Are two numbers not equal?
+
+**enum:** `!=`
+
+
+
+
+
+
+
+
+----
+Is left greater than right
+
+**enum:** `>`
+
+
+
+
+
+
+
+
+----
+Is left greater than or equal to right
+
+**enum:** `>=`
+
+
+
+
+
+
+
+
+----
+Is left less than right
+
+**enum:** `<`
+
+
+
+
+
+
+
+
+----
+Is left less than or equal to right
+
+**enum:** `<=`
+
+
+
+
+
+
+
+
 ----
 
 

docs/kcl/types/BodyItem.md

@@ -18,6 +18,27 @@ layout: manual
 
 
 
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `ImportStatement`|  | No |
+| `start` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `end` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `items` |`[` [`ImportItem`](/docs/kcl/types/ImportItem) `]`|  | No |
+| `path` |`string`|  | No |
+| `raw_path` |`string`|  | No |
+| `digest` |`[, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`]`|  | No |
+
+
+----
+
+**Type:** `object`
+
+
+
+
+
 ## Properties
 
 | Property | Type | Description | Required |
@@ -45,6 +66,7 @@ layout: manual
 | `start` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
 | `end` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
 | `declarations` |`[` [`VariableDeclarator`](/docs/kcl/types/VariableDeclarator) `]`|  | No |
+| `visibility` |[`ItemVisibility`](/docs/kcl/types/ItemVisibility)|  | No |
 | `kind` |[`VariableKind`](/docs/kcl/types/VariableKind)|  | No |
 | `digest` |`[, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`]`|  | No |
 

docs/kcl/types/CircularPattern2dData.md

@@ -16,7 +16,7 @@ Data for a circular pattern on a 2D sketch.
 
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
-| `repetitions` |[`Uint`](/docs/kcl/types/Uint)| The number of repetitions. Must be greater than 0. This excludes the original entity. For example, if `repetitions` is 1, the original entity will be copied once. | No |
+| `instances` |[`Uint`](/docs/kcl/types/Uint)| 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. | No |
 | `center` |`[number, number]`| The center about which to make the pattern. This is a 2D vector. | No |
 | `arcDegrees` |`number`| The arc angle (in degrees) to place the repetitions. Must be greater than 0. | No |
 | `rotateDuplicates` |`boolean`| Whether or not to rotate the duplicates as they are copied. | No |

docs/kcl/types/CircularPattern3dData.md

@@ -16,7 +16,7 @@ Data for a circular pattern on a 3D model.
 
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
-| `repetitions` |[`Uint`](/docs/kcl/types/Uint)| The number of repetitions. Must be greater than 0. This excludes the original entity. For example, if `repetitions` is 1, the original entity will be copied once. | No |
+| `instances` |[`Uint`](/docs/kcl/types/Uint)| 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. | No |
 | `axis` |`[number, number, number]`| The axis around which to make the pattern. This is a 3D vector. | No |
 | `center` |`[number, number, number]`| The center about which to make the pattern. This is a 3D vector. | No |
 | `arcDegrees` |`number`| The arc angle (in degrees) to place the repetitions. Must be greater than 0. | No |

docs/kcl/types/Expr.md

@@ -197,6 +197,27 @@ An expression can be evaluated to yield a single KCL value.
 
 
 
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `ArrayRangeExpression`|  | No |
+| `start` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `end` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `startElement` |[`Expr`](/docs/kcl/types/Expr)| An expression can be evaluated to yield a single KCL value. | No |
+| `endElement` |[`Expr`](/docs/kcl/types/Expr)| An expression can be evaluated to yield a single KCL value. | No |
+| `endInclusive` |`boolean`| Is the `end_element` included in the range? | No |
+| `digest` |`[, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`]`|  | No |
+
+
+----
+
+**Type:** `object`
+
+
+
+
+
 ## Properties
 
 | Property | Type | Description | Required |

docs/kcl/types/ImportItem.md

@@ -0,0 +1,24 @@
+---
+title: "ImportItem"
+excerpt: ""
+layout: manual
+---
+
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `name` |[`Identifier`](/docs/kcl/types/Identifier)| Name of the item to import. | No |
+| `alias` |[`Identifier`](/docs/kcl/types/Identifier)| Rename the item using an identifier after "as". | No |
+| `start` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `end` |[`EnvironmentRef`](/docs/kcl/types/EnvironmentRef)|  | No |
+| `digest` |`[, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`, `integer`]`|  | No |
+
+

docs/kcl/types/ItemVisibility.md

@@ -0,0 +1,16 @@
+---
+title: "ItemVisibility"
+excerpt: ""
+layout: manual
+---
+
+
+**enum:** `default`, `export`
+
+
+
+
+
+
+
+

docs/kcl/types/KclValue.md

@@ -1,10 +1,10 @@
 ---
 title: "KclValue"
-excerpt: "A memory item."
+excerpt: "Any KCL value."
 layout: manual
 ---
 
-A memory item.
+Any KCL value.
 
 
 
@@ -80,7 +80,7 @@ A plane.
 |----------|------|-------------|----------|
 | `type` |enum: `Plane`|  | No |
 | `id` |`string`| The id of the plane. | No |
-| `value` |[`PlaneType`](/docs/kcl/types/PlaneType)| A memory item. | No |
+| `value` |[`PlaneType`](/docs/kcl/types/PlaneType)| Any KCL value. | No |
 | `origin` |[`Point3d`](/docs/kcl/types/Point3d)| Origin of the plane. | No |
 | `xAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the plane’s X axis be? | No |
 | `yAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the plane’s Y axis be? | No |
@@ -183,8 +183,8 @@ Data for an imported geometry.
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
 | `type` |enum: `Function`|  | No |
-| `expression` |[`FunctionExpression`](/docs/kcl/types/FunctionExpression)| A memory item. | No |
-| `memory` |[`ProgramMemory`](/docs/kcl/types/ProgramMemory)| A memory item. | No |
+| `expression` |[`FunctionExpression`](/docs/kcl/types/FunctionExpression)| Any KCL value. | No |
+| `memory` |[`ProgramMemory`](/docs/kcl/types/ProgramMemory)| Any KCL value. | No |
 | `__meta` |`[` [`Metadata`](/docs/kcl/types/Metadata) `]`|  | No |
 
 

docs/kcl/types/LinearPattern2dData.md

@@ -16,7 +16,7 @@ Data for a linear pattern on a 2D sketch.
 
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
-| `repetitions` |[`Uint`](/docs/kcl/types/Uint)| The number of repetitions. Must be greater than 0. This excludes the original entity. For example, if `repetitions` is 1, the original entity will be copied once. | No |
+| `instances` |[`Uint`](/docs/kcl/types/Uint)| 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. | No |
 | `distance` |`number`| The distance between each repetition. This can also be referred to as spacing. | No |
 | `axis` |`[number, number]`| The axis of the pattern. This is a 2D vector. | No |
 

docs/kcl/types/LinearPattern3dData.md

@@ -16,7 +16,7 @@ Data for a linear pattern on a 3D model.
 
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
-| `repetitions` |[`Uint`](/docs/kcl/types/Uint)| The number of repetitions. Must be greater than 0. This excludes the original entity. For example, if `repetitions` is 1, the original entity will be copied once. | No |
+| `instances` |[`Uint`](/docs/kcl/types/Uint)| 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. | No |
 | `distance` |`number`| The distance between each repetition. This can also be referred to as spacing. | No |
 | `axis` |`[number, number, number]`| The axis of the pattern. | No |
 

e2e/playwright/debug-pane.spec.ts

@@ -0,0 +1,80 @@
+import { test, expect } from '@playwright/test'
+
+import { getUtils, setup, tearDown } from './test-utils'
+
+test.beforeEach(async ({ context, page }, testInfo) => {
+  await setup(context, page, testInfo)
+})
+
+test.afterEach(async ({ page }, testInfo) => {
+  await tearDown(page, testInfo)
+})
+
+function countNewlines(input: string): number {
+  let count = 0
+  for (const char of input) {
+    if (char === '\n') {
+      count++
+    }
+  }
+  return count
+}
+
+test.describe('Debug pane', () => {
+  test('Artifact IDs in the artifact graph are stable across code edits', async ({
+    page,
+    context,
+  }) => {
+    const code = `sketch001 = startSketchOn('XZ')
+  |> startProfileAt([0, 0], %)
+|> line([1, 1], %)
+`
+    const u = await getUtils(page)
+    await page.setViewportSize({ width: 1200, height: 500 })
+
+    const tree = page.getByTestId('debug-feature-tree')
+    const segment = tree.locator('li', {
+      hasText: 'segIds:',
+      hasNotText: 'paths:',
+    })
+
+    await test.step('Test setup', async () => {
+      await u.waitForAuthSkipAppStart()
+      await u.openKclCodePanel()
+      await u.openDebugPanel()
+      // Set the code in the code editor.
+      await u.codeLocator.click()
+      await page.keyboard.type(code, { delay: 0 })
+      // Scroll to the feature tree.
+      await tree.scrollIntoViewIfNeeded()
+      // Expand the feature tree.
+      await tree.getByText('Feature Tree').click()
+      // Just expanded the details, making the element taller, so scroll again.
+      await tree.getByText('Plane').first().scrollIntoViewIfNeeded()
+    })
+    // Extract the artifact IDs from the debug feature tree.
+    const initialSegmentIds = await segment.innerText({ timeout: 5_000 })
+    // The artifact ID should include a UUID.
+    expect(initialSegmentIds).toMatch(
+      /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/
+    )
+    await test.step('Move cursor to the bottom of the code editor', async () => {
+      // Focus on the code editor.
+      await u.codeLocator.click()
+      // Make sure the cursor is at the end of the code.
+      const lines = countNewlines(code) + 1
+      for (let i = 0; i < lines; i++) {
+        await page.keyboard.press('ArrowDown')
+      }
+    })
+    await test.step('Enter a comment', async () => {
+      await page.keyboard.type('|> line([2, 2], %)', { delay: 0 })
+      // Wait for keyboard input debounce and updated artifact graph.
+      await page.waitForTimeout(1000)
+    })
+    const newSegmentIds = await segment.innerText()
+    // Strip off the closing bracket.
+    const initialIds = initialSegmentIds.slice(0, initialSegmentIds.length - 1)
+    expect(newSegmentIds.slice(0, initialIds.length)).toEqual(initialIds)
+  })
+})

e2e/playwright/projects.spec.ts

@@ -1,4 +1,4 @@
-import { test, expect, Page } from '@playwright/test'
+import { test, expect } from '@playwright/test'
 import {
   doExport,
   executorInputPath,
@@ -618,31 +618,30 @@ test(
   'Deleting projects, can delete individual project, can still create projects after deleting all',
   { tag: '@electron' },
   async ({ browserName }, testInfo) => {
+    const projectData = [
+      ['router-template-slate', 'cylinder.kcl'],
+      ['bracket', 'focusrite_scarlett_mounting_braket.kcl'],
+      ['lego', 'lego.kcl'],
+    ]
+
     const { electronApp, page } = await setupElectron({
       testInfo,
+      folderSetupFn: async (dir) => {
+        // Do these serially to ensure the order is correct
+        for (const [name, file] of projectData) {
+          await fsp.mkdir(join(dir, name), { recursive: true })
+          await fsp.copyFile(
+            executorInputPath(file),
+            join(dir, name, `main.kcl`)
+          )
+          // Wait 1s between each project to ensure the order is correct
+          await new Promise((r) => setTimeout(r, 1_000))
+        }
+      },
     })
     await page.setViewportSize({ width: 1200, height: 500 })
-
     page.on('console', console.log)
 
-    const createProjectAndRenameItTest = async ({
-      name,
-      page,
-    }: {
-      name: string
-      page: Page
-    }) => {
-      await test.step(`Create and rename project ${name}`, async () => {
-        await createProjectAndRenameIt({ name, page })
-      })
-    }
-
-    // we need to create the folders so that the order is correct
-    // creating them ahead of time with fs tools means they all have the same timestamp
-    await createProjectAndRenameItTest({ name: 'router-template-slate', page })
-    await createProjectAndRenameItTest({ name: 'bracket', page })
-    await createProjectAndRenameItTest({ name: 'lego', page })
-
     await test.step('delete the middle project, i.e. the bracket project', async () => {
       const project = page.getByText('bracket')
 
@@ -744,8 +743,26 @@ test(
   'Can sort projects on home page',
   { tag: '@electron' },
   async ({ browserName }, testInfo) => {
+    const projectData = [
+      ['router-template-slate', 'cylinder.kcl'],
+      ['bracket', 'focusrite_scarlett_mounting_braket.kcl'],
+      ['lego', 'lego.kcl'],
+    ]
+
     const { electronApp, page } = await setupElectron({
       testInfo,
+      folderSetupFn: async (dir) => {
+        // Do these serially to ensure the order is correct
+        for (const [name, file] of projectData) {
+          await fsp.mkdir(join(dir, name), { recursive: true })
+          await fsp.copyFile(
+            executorInputPath(file),
+            join(dir, name, `main.kcl`)
+          )
+          // Wait 1s between each project to ensure the order is correct
+          await new Promise((r) => setTimeout(r, 1_000))
+        }
+      },
     })
     await page.setViewportSize({ width: 1200, height: 500 })
 
@@ -753,24 +770,6 @@ test(
 
     page.on('console', console.log)
 
-    const createProjectAndRenameItTest = async ({
-      name,
-      page,
-    }: {
-      name: string
-      page: Page
-    }) => {
-      await test.step(`Create and rename project ${name}`, async () => {
-        await createProjectAndRenameIt({ name, page })
-      })
-    }
-
-    // we need to create the folders so that the order is correct
-    // creating them ahead of time with fs tools means they all have the same timestamp
-    await createProjectAndRenameItTest({ name: 'router-template-slate', page })
-    await createProjectAndRenameItTest({ name: 'bracket', page })
-    await createProjectAndRenameItTest({ name: 'lego', page })
-
     await test.step('should be shorted by modified initially', async () => {
       const lastModifiedButton = page.getByRole('button', {
         name: 'Last Modified',

e2e/playwright/snapshot-tests.spec.ts

@@ -521,7 +521,6 @@ test(
     const startXPx = 600
 
     // Equip the rectangle tool
-    await page.getByRole('button', { name: 'line Line', exact: true }).click()
     await page
       .getByRole('button', { name: 'rectangle Corner rectangle', exact: true })
       .click()
@@ -670,6 +669,7 @@ test.describe(
       // screen shot should show the sketch
       await expect(page).toHaveScreenshot({
         maxDiffPixels: 100,
+        mask: [page.getByTestId('model-state-indicator')],
       })
 
       // exit sketch
@@ -687,6 +687,7 @@ test.describe(
       // second screen shot should look almost identical, i.e. scale should be the same.
       await expect(page).toHaveScreenshot({
         maxDiffPixels: 100,
+        mask: [page.getByTestId('model-state-indicator')],
       })
     })
 

e2e/playwright/testing-selections.spec.ts

@@ -1208,6 +1208,12 @@ extrude001 = extrude(50, sketch001)
   test('Deselecting line tool should mean nothing happens on click', async ({
     page,
   }) => {
+    /**
+     * If the line tool is clicked when the state is 'No Points' it will exit Sketch mode.
+     * This is the same exact workflow as pressing ESC.
+     *
+     * To continue to test this workflow, we now enter sketch mode and place a single point before exiting the line tool.
+     */
     const u = await getUtils(page)
     await page.setViewportSize({ width: 1200, height: 500 })
 
@@ -1228,6 +1234,7 @@ extrude001 = extrude(50, sketch001)
       200
     )
 
+    // Clicks the XZ Plane in the page
     await page.mouse.click(700, 200)
 
     await expect(page.locator('.cm-content')).toHaveText(
@@ -1236,6 +1243,11 @@ extrude001 = extrude(50, sketch001)
 
     await page.waitForTimeout(600)
 
+    // Place a point because the line tool will exit if no points are pressed
+    await page.mouse.click(650, 200)
+    await page.waitForTimeout(600)
+
+    // Code before exiting the tool
     let previousCodeContent = await page.locator('.cm-content').innerText()
 
     // deselect the line tool by clicking it

electron-builder.yml

@@ -73,3 +73,5 @@ publish:
   - provider: generic
     url: https://dl.zoo.dev/releases/modeling-app
     channel: latest
+releaseInfo:
+  releaseNotesFile: release-notes.md

interface.d.ts

@@ -69,9 +69,13 @@ export interface IElectronAPI {
   kittycad: (access: string, args: any) => any
   listMachines: () => Promise<MachinesListing>
   getMachineApiIp: () => Promise<string | null>
-  onUpdateDownloaded: (
-    callback: (value: string) => void
+  onUpdateDownloadStart: (
+    callback: (value: { version: string }) => void
   ) => Electron.IpcRenderer
+  onUpdateDownloaded: (
+    callback: (value: { version: string; releaseNotes: string }) => void
+  ) => Electron.IpcRenderer
+  onUpdateError: (callback: (value: { error: Error }) => void) => Electron
   appRestart: () => void
 }
 

openapi/machine-api.json

@@ -425,6 +425,34 @@
         ]
       }
     },
+    "/metrics": {
+      "get": {
+        "operationId": "get_metrics",
+        "responses": {
+          "200": {
+            "content": {
+              "application/json": {
+                "schema": {
+                  "title": "String",
+                  "type": "string"
+                }
+              }
+            },
+            "description": "successful operation"
+          },
+          "4XX": {
+            "$ref": "#/components/responses/Error"
+          },
+          "5XX": {
+            "$ref": "#/components/responses/Error"
+          }
+        },
+        "summary": "List available machines and their statuses",
+        "tags": [
+          "hidden"
+        ]
+      }
+    },
     "/ping": {
       "get": {
         "operationId": "ping",
@@ -492,6 +520,13 @@
     }
   },
   "tags": [
+    {
+      "description": "Hidden API endpoints that should not show up in the docs.",
+      "externalDocs": {
+        "url": "https://docs.zoo.dev/api/machines"
+      },
+      "name": "hidden"
+    },
     {
       "description": "Utilities for making parts and discovering machines.",
       "externalDocs": {

src/clientSideScene/ClientSideSceneComp.tsx

@@ -408,6 +408,7 @@ export async function deleteSegment({
 
   const testExecute = await executeAst({
     ast: modifiedAst,
+    idGenerator: kclManager.execState.idGenerator,
     useFakeExecutor: true,
     engineCommandManager: engineCommandManager,
   })

src/clientSideScene/sceneEntities.ts

@@ -391,12 +391,14 @@ export class SceneEntities {
     const { truncatedAst, programMemoryOverride, variableDeclarationName } =
       prepared
 
-    const { programMemory } = await executeAst({
+    const { execState } = await executeAst({
       ast: truncatedAst,
       useFakeExecutor: true,
       engineCommandManager: this.engineCommandManager,
       programMemoryOverride,
+      idGenerator: kclManager.execState.idGenerator,
     })
+    const programMemory = execState.memory
     const sketch = sketchFromPathToNode({
       pathToNode: sketchPathToNode,
       ast: maybeModdedAst,
@@ -801,12 +803,14 @@ export class SceneEntities {
           updateRectangleSketch(sketchInit, x, y, tags[0])
         }
 
-        const { programMemory } = await executeAst({
+        const { execState } = await executeAst({
           ast: truncatedAst,
           useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
+        const programMemory = execState.memory
         this.sceneProgramMemory = programMemory
         const sketch = sketchFromKclValue(
           programMemory.get(variableDeclarationName),
@@ -848,12 +852,14 @@ export class SceneEntities {
           await kclManager.executeAstMock(_ast)
           sceneInfra.modelingSend({ type: 'Finish rectangle' })
 
-          const { programMemory } = await executeAst({
+          const { execState } = await executeAst({
             ast: _ast,
             useFakeExecutor: true,
             engineCommandManager: this.engineCommandManager,
             programMemoryOverride,
+            idGenerator: kclManager.execState.idGenerator,
           })
+          const programMemory = execState.memory
 
           // Prepare to update the THREEjs scene
           this.sceneProgramMemory = programMemory
@@ -965,12 +971,14 @@ export class SceneEntities {
           modded = moddedResult.modifiedAst
         }
 
-        const { programMemory } = await executeAst({
+        const { execState } = await executeAst({
           ast: modded,
           useFakeExecutor: true,
           engineCommandManager: this.engineCommandManager,
           programMemoryOverride,
+          idGenerator: kclManager.execState.idGenerator,
         })
+        const programMemory = execState.memory
         this.sceneProgramMemory = programMemory
         const sketch = sketchFromKclValue(
           programMemory.get(variableDeclarationName),
@@ -1317,12 +1325,14 @@ export class SceneEntities {
         // don't want to mod the user's code yet as they have't committed to the change yet
         // plus this would be the truncated ast being recast, it would be wrong
         codeManager.updateCodeEditor(code)
-      const { programMemory } = await executeAst({
+      const { execState } = await executeAst({
         ast: truncatedAst,
         useFakeExecutor: true,
         engineCommandManager: this.engineCommandManager,
         programMemoryOverride,
+        idGenerator: kclManager.execState.idGenerator,
       })
+      const programMemory = execState.memory
       this.sceneProgramMemory = programMemory
 
       const maybeSketch = programMemory.get(variableDeclarationName)

src/components/AvailableVarsHelpers.tsx

@@ -157,7 +157,7 @@ export function useCalc({
         engineCommandManager,
         useFakeExecutor: true,
         programMemoryOverride: kclManager.programMemory.clone(),
-      }).then(({ programMemory }) => {
+      }).then(({ execState }) => {
         const resultDeclaration = ast.body.find(
           (a) =>
             a.type === 'VariableDeclaration' &&
@@ -166,7 +166,7 @@ export function useCalc({
         const init =
           resultDeclaration?.type === 'VariableDeclaration' &&
           resultDeclaration?.declarations?.[0]?.init
-        const result = programMemory?.get('__result__')?.value
+        const result = execState.memory?.get('__result__')?.value
         setCalcResult(typeof result === 'number' ? String(result) : 'NAN')
         init && setValueNode(init)
       })

src/components/DebugDisplayObj.tsx

@@ -0,0 +1,111 @@
+import { isArray, isNonNullable } from 'lib/utils'
+import { useRef, useState } from 'react'
+
+type Primitive = string | number | bigint | boolean | symbol | null | undefined
+
+export type GenericObj = {
+  type?: string
+  [key: string]: GenericObj | Primitive | Array<GenericObj | Primitive>
+}
+
+/**
+ * Display an array of objects or primitives for debug purposes. Nullable values
+ * are displayed so that relative indexes are preserved.
+ */
+export function DebugDisplayArray({
+  arr,
+  filterKeys,
+}: {
+  arr: Array<GenericObj | Primitive>
+  filterKeys: string[]
+}) {
+  return (
+    <>
+      {arr.map((obj, index) => {
+        return (
+          <div className="my-2" key={index}>
+            {obj && typeof obj === 'object' ? (
+              <DebugDisplayObj obj={obj} filterKeys={filterKeys} />
+            ) : isNonNullable(obj) ? (
+              <span>{obj.toString()}</span>
+            ) : (
+              <span>{obj}</span>
+            )}
+          </div>
+        )
+      })}
+    </>
+  )
+}
+
+/**
+ * Display an object as a tree for debug purposes. Nullable values are omitted.
+ * The only other property treated specially is the type property, which is
+ * assumed to be a string.
+ */
+export function DebugDisplayObj({
+  obj,
+  filterKeys,
+}: {
+  obj: GenericObj
+  filterKeys: string[]
+}) {
+  const ref = useRef<HTMLPreElement>(null)
+  const hasCursor = false
+  const [isCollapsed, setIsCollapsed] = useState(false)
+  return (
+    <pre
+      ref={ref}
+      className={`ml-2 border-l border-violet-600 pl-1 ${
+        hasCursor ? 'bg-violet-100/80 dark:bg-violet-100/25' : ''
+      }`}
+    >
+      {isCollapsed ? (
+        <button
+          className="m-0 p-0 border-0"
+          onClick={() => setIsCollapsed(false)}
+        >
+          {'>'}type: {obj.type}
+        </button>
+      ) : (
+        <span className="flex">
+          <button
+            className="m-0 p-0 border-0 mb-auto"
+            onClick={() => setIsCollapsed(true)}
+          >
+            {'⬇️'}
+          </button>
+          <ul className="inline-block">
+            {Object.entries(obj).map(([key, value]) => {
+              if (filterKeys.includes(key)) {
+                return null
+              } else if (isArray(value)) {
+                return (
+                  <li key={key}>
+                    {`${key}: [`}
+                    <DebugDisplayArray arr={value} filterKeys={filterKeys} />
+                    {']'}
+                  </li>
+                )
+              } else if (typeof value === 'object' && value !== null) {
+                return (
+                  <li key={key}>
+                    {key}:
+                    <DebugDisplayObj obj={value} filterKeys={filterKeys} />
+                  </li>
+                )
+              } else if (isNonNullable(value)) {
+                return (
+                  <li key={key}>
+                    {key}: {value.toString()}
+                  </li>
+                )
+              }
+              return null
+            })}
+          </ul>
+        </span>
+      )}
+    </pre>
+  )
+}

src/components/DebugFeatureTree.tsx

@@ -0,0 +1,45 @@
+import { useMemo } from 'react'
+import { engineCommandManager } from 'lib/singletons'
+import {
+  ArtifactGraph,
+  expandPlane,
+  PlaneArtifactRich,
+} from 'lang/std/artifactGraph'
+import { DebugDisplayArray, GenericObj } from './DebugDisplayObj'
+
+export function DebugFeatureTree() {
+  const featureTree = useMemo(() => {
+    return computeTree(engineCommandManager.artifactGraph)
+  }, [engineCommandManager.artifactGraph])
+
+  const filterKeys: string[] = ['__meta', 'codeRef', 'pathToNode']
+  return (
+    <details data-testid="debug-feature-tree" className="relative">
+      <summary>Feature Tree</summary>
+      {featureTree.length > 0 ? (
+        <pre className="text-xs">
+          <DebugDisplayArray arr={featureTree} filterKeys={filterKeys} />
+        </pre>
+      ) : (
+        <p>(Empty)</p>
+      )}
+    </details>
+  )
+}
+
+function computeTree(artifactGraph: ArtifactGraph): GenericObj[] {
+  let items: GenericObj[] = []
+
+  const planes: PlaneArtifactRich[] = []
+  for (const artifact of artifactGraph.values()) {
+    if (artifact.type === 'plane') {
+      planes.push(expandPlane(artifact, artifactGraph))
+    }
+  }
+  const extraRichPlanes: GenericObj[] = planes.map((plane) => {
+    return plane as any as GenericObj
+  })
+  items = items.concat(extraRichPlanes)
+
+  return items
+}

src/components/ModelingMachineProvider.tsx

@@ -149,6 +149,13 @@ export const ModelingMachineProvider = ({
         },
         'sketch exit execute': ({ context: { store } }) => {
           ;(async () => {
+            // When cancelling the sketch mode we should disable sketch mode within the engine.
+            await engineCommandManager.sendSceneCommand({
+              type: 'modeling_cmd_req',
+              cmd_id: uuidv4(),
+              cmd: { type: 'sketch_mode_disable' },
+            })
+
             sceneInfra.camControls.syncDirection = 'clientToEngine'
 
             if (cameraProjection.current === 'perspective') {

src/components/ModelingSidebar/ModelingPanes/DebugPane.tsx

@@ -1,3 +1,4 @@
+import { DebugFeatureTree } from 'components/DebugFeatureTree'
 import { AstExplorer } from '../../AstExplorer'
 import { EngineCommands } from '../../EngineCommands'
 import { CamDebugSettings } from 'clientSideScene/ClientSideSceneComp'
@@ -12,6 +13,7 @@ export const DebugPane = () => {
         <EngineCommands />
         <CamDebugSettings />
         <AstExplorer />
+        <DebugFeatureTree />
       </div>
     </section>
   )

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

@@ -29,8 +29,8 @@ describe('processMemory', () => {
     |> lineTo([2.15, 4.32], %)
     // |> rx(90, %)`
     const ast = parse(code)
-    const programMemory = await enginelessExecutor(ast, ProgramMemory.empty())
-    const output = processMemory(programMemory)
+    const execState = await enginelessExecutor(ast, ProgramMemory.empty())
+    const output = processMemory(execState.memory)
     expect(output.myVar).toEqual(5)
     expect(output.otherVar).toEqual(3)
     expect(output).toEqual({

src/components/ToastUpdate.test.tsx

@@ -0,0 +1,153 @@
+import { fireEvent, render, screen } from '@testing-library/react'
+import { vi } from 'vitest'
+import { ToastUpdate } from './ToastUpdate'
+
+describe('ToastUpdate tests', () => {
+  const testData = {
+    version: '0.255.255',
+    files: [
+      {
+        url: 'Zoo Modeling App-0.255.255-x64-mac.zip',
+        sha512:
+          'VJb0qlrqNr+rVx3QLATz+B28dtHw3osQb5/+UUmQUIMuF9t0i8dTKOVL/2lyJSmLJVw2/SGDB4Ud6VlTPJ6oFw==',
+        size: 141277345,
+      },
+      {
+        url: 'Zoo Modeling App-0.255.255-arm64-mac.zip',
+        sha512:
+          'b+ugdg7A4LhYYJaFkPRxh1RvmGGMlPJJj7inkLg9PwRtCnR9ePMlktj2VRciXF1iLh59XW4bLc4dK1dFQHMULA==',
+        size: 135278259,
+      },
+      {
+        url: 'Zoo Modeling App-0.255.255-x64-mac.dmg',
+        sha512:
+          'gCUqww05yj8OYwPiTq6bo5GbkpngSbXGtenmDD7+kUm0UyVK8WD3dMAfQJtGNG5HY23aHCHe9myE2W4mbZGmiQ==',
+        size: 146004232,
+      },
+      {
+        url: 'Zoo Modeling App-0.255.255-arm64-mac.dmg',
+        sha512:
+          'ND871ayf81F1ZT+iWVLYTc2jdf/Py6KThuxX2QFWz14ebmIbJPL07lNtxQOexOFiuk0MwRhlCy1RzOSG1b9bmw==',
+        size: 140021522,
+      },
+    ],
+    path: 'Zoo Modeling App-0.255.255-x64-mac.zip',
+    sha512:
+      'VJb0qlrqNr+rVx3QLATz+B28dtHw3osQb5/+UUmQUIMuF9t0i8dTKOVL/2lyJSmLJVw2/SGDB4Ud6VlTPJ6oFw==',
+    releaseNotes:
+      '## Some markdown release notes\n\n- This is a list item\n- This is another list item\n\n```javascript\nconsole.log("Hello, world!")\n```\n',
+    releaseDate: '2024-10-09T11:57:59.133Z',
+  } as const
+
+  test('Happy path: renders the toast with good data', () => {
+    const onRestart = vi.fn()
+    const onDismiss = vi.fn()
+
+    render(
+      <ToastUpdate
+        onRestart={onRestart}
+        onDismiss={onDismiss}
+        version={testData.version}
+        releaseNotes={testData.releaseNotes}
+      />
+    )
+
+    // Locators and other constants
+    const versionText = screen.getByTestId('update-version')
+    const restartButton = screen.getByRole('button', { name: /restart/i })
+    const dismissButton = screen.getByRole('button', { name: /got it/i })
+    const releaseNotes = screen.getByTestId('release-notes')
+
+    expect(versionText).toBeVisible()
+    expect(versionText).toHaveTextContent(testData.version)
+
+    expect(restartButton).toBeEnabled()
+    fireEvent.click(restartButton)
+    expect(onRestart.mock.calls).toHaveLength(1)
+
+    expect(dismissButton).toBeEnabled()
+    fireEvent.click(dismissButton)
+    expect(onDismiss.mock.calls).toHaveLength(1)
+
+    // I cannot for the life of me seem to get @testing-library/react
+    // to properly handle click events or visibility checks on the details element.
+    // So I'm only checking that the content is in the document.
+    expect(releaseNotes).toBeInTheDocument()
+    expect(releaseNotes).toHaveTextContent('Release notes')
+    const releaseNotesListItems = screen.getAllByRole('listitem')
+    expect(releaseNotesListItems.map((el) => el.textContent)).toEqual([
+      'This is a list item',
+      'This is another list item',
+    ])
+  })
+
+  test('Happy path: renders the breaking changes notice', () => {
+    const releaseNotesWithBreakingChanges = `
+## Some markdown release notes
+- This is a list item
+- This is another list item with a breaking change
+- This is a list item
+`
+    const onRestart = vi.fn()
+    const onDismiss = vi.fn()
+
+    render(
+      <ToastUpdate
+        onRestart={onRestart}
+        onDismiss={onDismiss}
+        version={testData.version}
+        releaseNotes={releaseNotesWithBreakingChanges}
+      />
+    )
+
+    // Locators and other constants
+    const releaseNotes = screen.getByText('Release notes', {
+      selector: 'summary',
+    })
+    const listItemContents = screen
+      .getAllByRole('listitem')
+      .map((el) => el.textContent)
+
+    // I cannot for the life of me seem to get @testing-library/react
+    // to properly handle click events or visibility checks on the details element.
+    // So I'm only checking that the content is in the document.
+    expect(releaseNotes).toBeInTheDocument()
+    expect(listItemContents).toEqual([
+      'This is a list item',
+      'This is another list item with a breaking change',
+      'This is a list item',
+    ])
+  })
+
+  test('Missing release notes: renders the toast without release notes', () => {
+    const onRestart = vi.fn()
+    const onDismiss = vi.fn()
+
+    render(
+      <ToastUpdate
+        onRestart={onRestart}
+        onDismiss={onDismiss}
+        version={testData.version}
+        releaseNotes={''}
+      />
+    )
+
+    // Locators and other constants
+    const versionText = screen.getByTestId('update-version')
+    const restartButton = screen.getByRole('button', { name: /restart/i })
+    const dismissButton = screen.getByRole('button', { name: /got it/i })
+    const releaseNotes = screen.queryByText(/release notes/i, {
+      selector: 'details > summary',
+    })
+    const releaseNotesListItem = screen.queryByRole('listitem', {
+      name: /this is a list item/i,
+    })
+
+    expect(versionText).toBeVisible()
+    expect(versionText).toHaveTextContent(testData.version)
+    expect(releaseNotes).not.toBeInTheDocument()
+    expect(releaseNotesListItem).not.toBeInTheDocument()
+    expect(restartButton).toBeEnabled()
+    expect(dismissButton).toBeEnabled()
+  })
+})

src/components/ToastUpdate.tsx

@@ -1,14 +1,23 @@
 import toast from 'react-hot-toast'
 import { ActionButton } from './ActionButton'
 import { openExternalBrowserIfDesktop } from 'lib/openWindow'
+import { Marked } from '@ts-stack/markdown'
 
 export function ToastUpdate({
   version,
+  releaseNotes,
   onRestart,
+  onDismiss,
 }: {
   version: string
+  releaseNotes?: string
   onRestart: () => void
+  onDismiss: () => void
 }) {
+  const containsBreakingChanges = releaseNotes
+    ?.toLocaleLowerCase()
+    .includes('breaking')
+
   return (
     <div className="inset-0 z-50 grid place-content-center rounded bg-chalkboard-110/50 shadow-md">
       <div className="max-w-3xl min-w-[35rem] p-8 rounded bg-chalkboard-10 dark:bg-chalkboard-90">
@@ -19,7 +28,7 @@ export function ToastUpdate({
           >
             v{version}
           </span>
-          <span className="ml-4 text-md text-bold">
+          <p className="ml-4 text-md text-bold">
             A new update has downloaded and will be available next time you
             start the app. You can view the release notes{' '}
             <a
@@ -32,15 +41,39 @@ export function ToastUpdate({
             >
               here on GitHub.
             </a>
-          </span>
+          </p>
         </div>
+        {releaseNotes && (
+          <details
+            className="my-4 border border-chalkboard-30 dark:border-chalkboard-60 rounded"
+            open={containsBreakingChanges}
+            data-testid="release-notes"
+          >
+            <summary className="p-2 select-none cursor-pointer">
+              Release notes
+              {containsBreakingChanges && (
+                <strong className="text-destroy-50"> (Breaking changes)</strong>
+              )}
+            </summary>
+            <div
+              className="parsed-markdown py-2 px-4 mt-2 border-t border-chalkboard-30 dark:border-chalkboard-60 max-h-60 overflow-y-auto"
+              dangerouslySetInnerHTML={{
+                __html: Marked.parse(releaseNotes, {
+                  gfm: true,
+                  breaks: true,
+                  sanitize: true,
+                }),
+              }}
+            ></div>
+          </details>
+        )}
         <div className="flex justify-between gap-8">
           <ActionButton
             Element="button"
             iconStart={{
               icon: 'arrowRotateRight',
             }}
-            name="Restart app now"
+            name="restart"
             onClick={onRestart}
           >
             Restart app now
@@ -50,9 +83,10 @@ export function ToastUpdate({
             iconStart={{
               icon: 'checkmark',
             }}
-            name="Got it"
+            name="dismiss"
             onClick={() => {
               toast.dismiss()
+              onDismiss()
             }}
           >
             Got it

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

@@ -1,6 +1,9 @@
 import { styleTags, tags as t } from '@lezer/highlight'
 
 export const kclHighlight = styleTags({
+  'import export': t.moduleKeyword,
+  ImportItemAs: t.definitionKeyword,
+  ImportFrom: t.moduleKeyword,
   'fn var let const': t.definitionKeyword,
   'if else': t.controlKeyword,
   return: t.controlKeyword,

src/editor/plugins/lsp/kcl/kcl.grammar

@@ -15,8 +15,9 @@
 }
 
 statement[@isGroup=Statement] {
-  FunctionDeclaration { kw<"fn"> VariableDefinition Equals ParamList Arrow Body } |
-  VariableDeclaration { (kw<"var"> | kw<"let"> | kw<"const">)? VariableDefinition Equals expression } |
+  ImportStatement { kw<"import"> ImportItems ImportFrom String } |
+  FunctionDeclaration { kw<"export">? kw<"fn"> VariableDefinition Equals ParamList Arrow Body } |
+  VariableDeclaration { kw<"export">? (kw<"var"> | kw<"let"> | kw<"const">)? VariableDefinition Equals expression } |
   ReturnStatement { kw<"return"> expression } |
   ExpressionStatement { expression }
 }
@@ -25,6 +26,9 @@ ParamList { "(" commaSep<Parameter { VariableDefinition "?"? (":" type)? }> ")"
 
 Body { "{" statement* "}" }
 
+ImportItems { commaSep1NoTrailingComma<ImportItem> }
+ImportItem { identifier (ImportItemAs identifier)? }
+
 expression[@isGroup=Expression] {
   String |
   Number |
@@ -74,6 +78,8 @@ kw<term> { @specialize[@name={term}]<identifier, term> }
 
 commaSep<term> { (term ("," term)*)? ","? }
 
+commaSep1NoTrailingComma<term> { term ("," term)* }
+
 @tokens {
   String[isolate] { "'" ("\\" _ | !['\\])* "'" | '"' ("\\" _ | !["\\])* '"' }
 
@@ -106,6 +112,9 @@ commaSep<term> { (term ("," term)*)? ","? }
 
   Shebang { "#!" ![\n]* }
 
+  ImportItemAs { "as" }
+  ImportFrom { "from" }
+
   "(" ")"
   "{" "}"
   "[" "]"

src/index.css

@@ -293,6 +293,24 @@ code {
     which lets you use them with @apply in your CSS, and get 
     autocomplete in classNames in your JSX.
   */
+  .parsed-markdown ul,
+  .parsed-markdown ol {
+    @apply list-outside pl-4 lg:pl-8 my-2;
+  }
+
+  .parsed-markdown ul li {
+    @apply list-disc;
+  }
+
+  .parsed-markdown li p {
+    @apply inline;
+  }
+
+  .parsed-markdown code {
+    @apply px-1 py-0.5 rounded-sm;
+    @apply bg-chalkboard-20 text-chalkboard-80;
+    @apply dark:bg-chalkboard-80 dark:text-chalkboard-30;
+  }
 }
 
 #code-mirror-override .cm-scroller,

src/index.tsx

@@ -8,6 +8,7 @@ import ModalContainer from 'react-modal-promise'
 import { isDesktop } from 'lib/isDesktop'
 import { AppStreamProvider } from 'AppState'
 import { ToastUpdate } from 'components/ToastUpdate'
+import { AUTO_UPDATER_TOAST_ID } from 'lib/constants'
 
 // uncomment for xstate inspector
 // import { DEV } from 'env'
@@ -53,17 +54,35 @@ root.render(
 // or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
 reportWebVitals()
 
-isDesktop() &&
-  window.electron.onUpdateDownloaded((version: string) => {
+if (isDesktop()) {
+  // Listen for update download progress to begin
+  // to show a loading toast.
+  window.electron.onUpdateDownloadStart(() => {
+    const message = `Downloading app update...`
+    console.log(message)
+    toast.loading(message, { id: AUTO_UPDATER_TOAST_ID })
+  })
+  // Listen for update download errors to show
+  // an error toast and clear the loading toast.
+  window.electron.onUpdateError(({ error }) => {
+    console.error(error)
+    toast.error('An error occurred while downloading the update.', {
+      id: AUTO_UPDATER_TOAST_ID,
+    })
+  })
+  window.electron.onUpdateDownloaded(({ version, releaseNotes }) => {
     const message = `A new update (${version}) was downloaded and will be available next time you open the app.`
     console.log(message)
     toast.custom(
       ToastUpdate({
         version,
+        releaseNotes,
         onRestart: () => {
           window.electron.appRestart()
         },
+        onDismiss: () => {},
       }),
-      { duration: 30000 }
+      { duration: 30000, id: AUTO_UPDATER_TOAST_ID }
     )
   })
+}

src/lang/KclSingleton.ts

@@ -8,6 +8,8 @@ import { EXECUTE_AST_INTERRUPT_ERROR_MESSAGE } from 'lib/constants'
 
 import {
   CallExpression,
+  emptyExecState,
+  ExecState,
   initPromise,
   parse,
   PathToNode,
@@ -42,6 +44,7 @@ export class KclManager {
     },
     digest: null,
   }
+  private _execState: ExecState = emptyExecState()
   private _programMemory: ProgramMemory = ProgramMemory.empty()
   lastSuccessfulProgramMemory: ProgramMemory = ProgramMemory.empty()
   private _logs: string[] = []
@@ -72,11 +75,21 @@ export class KclManager {
   get programMemory() {
     return this._programMemory
   }
-  set programMemory(programMemory) {
+  // This is private because callers should be setting the entire execState.
+  private set programMemory(programMemory) {
     this._programMemory = programMemory
     this._programMemoryCallBack(programMemory)
   }
 
+  set execState(execState) {
+    this._execState = execState
+    this.programMemory = execState.memory
+  }
+
+  get execState() {
+    return this._execState
+  }
+
   get logs() {
     return this._logs
   }
@@ -253,8 +266,9 @@ export class KclManager {
     // Make sure we clear before starting again. End session will do this.
     this.engineCommandManager?.endSession()
     await this.ensureWasmInit()
-    const { logs, errors, programMemory, isInterrupted } = await executeAst({
+    const { logs, errors, execState, isInterrupted } = await executeAst({
       ast,
+      idGenerator: this.execState.idGenerator,
       engineCommandManager: this.engineCommandManager,
     })
 
@@ -264,7 +278,7 @@ export class KclManager {
       this.lints = await lintAst({ ast: ast })
 
       sceneInfra.modelingSend({ type: 'code edit during sketch' })
-      defaultSelectionFilter(programMemory, this.engineCommandManager)
+      defaultSelectionFilter(execState.memory, this.engineCommandManager)
 
       if (args.zoomToFit) {
         let zoomObjectId: string | undefined = ''
@@ -295,12 +309,20 @@ export class KclManager {
       this._cancelTokens.delete(currentExecutionId)
       return
     }
+
+    // Exit sketch mode if the AST is empty
+    if (this._isAstEmpty(ast)) {
+      await this.disableSketchMode()
+    }
+
     this.logs = logs
     // Do not add the errors since the program was interrupted and the error is not a real KCL error
     this.addKclErrors(isInterrupted ? [] : errors)
-    this.programMemory = programMemory
+    // Reset the next ID index so that we reuse the previous IDs next time.
+    execState.idGenerator.nextId = 0
+    this.execState = execState
     if (!errors.length) {
-      this.lastSuccessfulProgramMemory = programMemory
+      this.lastSuccessfulProgramMemory = execState.memory
     }
     this.ast = { ...ast }
     this._executeCallback()
@@ -338,17 +360,19 @@ export class KclManager {
     await codeManager.writeToFile()
     this._ast = { ...newAst }
 
-    const { logs, errors, programMemory } = await executeAst({
+    const { logs, errors, execState } = await executeAst({
       ast: newAst,
+      idGenerator: this.execState.idGenerator,
       engineCommandManager: this.engineCommandManager,
       useFakeExecutor: true,
     })
 
     this._logs = logs
     this._kclErrors = errors
-    this._programMemory = programMemory
+    this._execState = execState
+    this._programMemory = execState.memory
     if (!errors.length) {
-      this.lastSuccessfulProgramMemory = programMemory
+      this.lastSuccessfulProgramMemory = execState.memory
     }
     if (updates !== 'artifactRanges') return
 
@@ -553,6 +577,24 @@ export class KclManager {
   defaultSelectionFilter() {
     defaultSelectionFilter(this.programMemory, this.engineCommandManager)
   }
+
+  /**
+   * We can send a single command of 'enable_sketch_mode' or send this in a batched request.
+   * When there is no code in the KCL editor we should be sending 'sketch_mode_disable' since any previous half finished
+   * code could leave the state of the application in sketch mode on the engine side.
+   */
+  async disableSketchMode() {
+    await this.engineCommandManager.sendSceneCommand({
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: { type: 'sketch_mode_disable' },
+    })
+  }
+
+  // Determines if there is no KCL code which means it is executing a blank KCL file
+  _isAstEmpty(ast: Program) {
+    return ast.start === 0 && ast.end === 0 && ast.body.length === 0
+  }
 }
 
 function defaultSelectionFilter(

src/lang/artifact.test.ts

@@ -14,9 +14,9 @@ const mySketch001 = startSketchOn('XY')
   |> lineTo([-1.59, -1.54], %)
   |> lineTo([0.46, -5.82], %)
   // |> rx(45, %)`
-    const programMemory = await enginelessExecutor(parse(code))
+    const execState = await enginelessExecutor(parse(code))
     // @ts-ignore
-    const sketch001 = programMemory?.get('mySketch001')
+    const sketch001 = execState.memory.get('mySketch001')
     expect(sketch001).toEqual({
       type: 'UserVal',
       __meta: [{ sourceRange: [46, 71] }],
@@ -68,9 +68,9 @@ const mySketch001 = startSketchOn('XY')
   |> lineTo([0.46, -5.82], %)
   // |> rx(45, %)
   |> extrude(2, %)`
-    const programMemory = await enginelessExecutor(parse(code))
+    const execState = await enginelessExecutor(parse(code))
     // @ts-ignore
-    const sketch001 = programMemory?.get('mySketch001')
+    const sketch001 = execState.memory.get('mySketch001')
     expect(sketch001).toEqual({
       type: 'Solid',
       id: expect.any(String),
@@ -148,9 +148,10 @@ const sk2 = startSketchOn('XY')
   |> extrude(2, %)
 
 `
-    const programMemory = await enginelessExecutor(parse(code))
+    const execState = await enginelessExecutor(parse(code))
+    const programMemory = execState.memory
     // @ts-ignore
-    const geos = [programMemory?.get('theExtrude'), programMemory?.get('sk2')]
+    const geos = [programMemory.get('theExtrude'), programMemory.get('sk2')]
     expect(geos).toEqual([
       {
         type: 'Solid',

src/lang/executor.test.ts

@@ -443,6 +443,6 @@ async function exe(
 ) {
   const ast = parse(code)
 
-  const result = await enginelessExecutor(ast, programMemory)
-  return result
+  const execState = await enginelessExecutor(ast, programMemory)
+  return execState.memory
 }

src/lang/langHelpers.ts

@@ -4,11 +4,14 @@ import {
   ProgramMemory,
   programMemoryInit,
   kclLint,
+  emptyExecState,
+  ExecState,
 } from 'lang/wasm'
 import { enginelessExecutor } from 'lib/testHelpers'
 import { EngineCommandManager } from 'lang/std/engineConnection'
 import { KCLError } from 'lang/errors'
 import { Diagnostic } from '@codemirror/lint'
+import { IdGenerator } from 'wasm-lib/kcl/bindings/IdGenerator'
 
 export type ToolTip =
   | 'lineTo'
@@ -47,16 +50,18 @@ export async function executeAst({
   engineCommandManager,
   useFakeExecutor = false,
   programMemoryOverride,
+  idGenerator,
 }: {
   ast: Program
   engineCommandManager: EngineCommandManager
   useFakeExecutor?: boolean
   programMemoryOverride?: ProgramMemory
+  idGenerator?: IdGenerator
   isInterrupted?: boolean
 }): Promise<{
   logs: string[]
   errors: KCLError[]
-  programMemory: ProgramMemory
+  execState: ExecState
   isInterrupted: boolean
 }> {
   try {
@@ -65,15 +70,21 @@ export async function executeAst({
       // eslint-disable-next-line @typescript-eslint/no-floating-promises
       engineCommandManager.startNewSession()
     }
-    const programMemory = await (useFakeExecutor
+    const execState = await (useFakeExecutor
       ? enginelessExecutor(ast, programMemoryOverride || programMemoryInit())
-      : _executor(ast, programMemoryInit(), engineCommandManager, false))
+      : _executor(
+          ast,
+          programMemoryInit(),
+          idGenerator,
+          engineCommandManager,
+          false
+        ))
 
     await engineCommandManager.waitForAllCommands()
     return {
       logs: [],
       errors: [],
-      programMemory,
+      execState,
       isInterrupted: false,
     }
   } catch (e: any) {
@@ -89,7 +100,7 @@ export async function executeAst({
       return {
         errors: [e],
         logs: [],
-        programMemory: ProgramMemory.empty(),
+        execState: emptyExecState(),
         isInterrupted,
       }
     } else {
@@ -97,7 +108,7 @@ export async function executeAst({
       return {
         logs: [e],
         errors: [],
-        programMemory: ProgramMemory.empty(),
+        execState: emptyExecState(),
         isInterrupted,
       }
     }

src/lang/modifyAst.test.ts

@@ -220,11 +220,11 @@ yo2 = hmm([identifierGuy + 5])`
   it('should move a binary expression into a new variable', async () => {
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const startIndex = code.indexOf('100 + 100') + 1
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
-      programMemory,
+      execState.memory,
       [startIndex, startIndex],
       'newVar'
     )
@@ -235,11 +235,11 @@ yo2 = hmm([identifierGuy + 5])`
   it('should move a value into a new variable', async () => {
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const startIndex = code.indexOf('2.8') + 1
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
-      programMemory,
+      execState.memory,
       [startIndex, startIndex],
       'newVar'
     )
@@ -250,11 +250,11 @@ yo2 = hmm([identifierGuy + 5])`
   it('should move a callExpression into a new variable', async () => {
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const startIndex = code.indexOf('def(')
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
-      programMemory,
+      execState.memory,
       [startIndex, startIndex],
       'newVar'
     )
@@ -265,11 +265,11 @@ yo2 = hmm([identifierGuy + 5])`
   it('should move a binary expression with call expression into a new variable', async () => {
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const startIndex = code.indexOf('jkl(') + 1
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
-      programMemory,
+      execState.memory,
       [startIndex, startIndex],
       'newVar'
     )
@@ -280,11 +280,11 @@ yo2 = hmm([identifierGuy + 5])`
   it('should move a identifier into a new variable', async () => {
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const startIndex = code.indexOf('identifierGuy +') + 1
     const { modifiedAst } = moveValueIntoNewVariable(
       ast,
-      programMemory,
+      execState.memory,
       [startIndex, startIndex],
       'newVar'
     )
@@ -465,7 +465,7 @@ describe('Testing deleteSegmentFromPipeExpression', () => {
   |> line([306.21, 198.87], %)`
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const lineOfInterest = 'line([306.21, 198.85], %, $a)'
     const range: [number, number] = [
       code.indexOf(lineOfInterest),
@@ -475,7 +475,7 @@ describe('Testing deleteSegmentFromPipeExpression', () => {
     const modifiedAst = deleteSegmentFromPipeExpression(
       [],
       ast,
-      programMemory,
+      execState.memory,
       code,
       pathToNode
     )
@@ -543,7 +543,7 @@ ${!replace1 ? `  |> ${line}\n` : ''}  |> angledLine([-65, ${
       const code = makeCode(line)
       const ast = parse(code)
       if (err(ast)) throw ast
-      const programMemory = await enginelessExecutor(ast)
+      const execState = await enginelessExecutor(ast)
       const lineOfInterest = line
       const range: [number, number] = [
         code.indexOf(lineOfInterest),
@@ -554,7 +554,7 @@ ${!replace1 ? `  |> ${line}\n` : ''}  |> angledLine([-65, ${
       const modifiedAst = deleteSegmentFromPipeExpression(
         dependentSegments,
         ast,
-        programMemory,
+        execState.memory,
         code,
         pathToNode
       )
@@ -632,7 +632,7 @@ describe('Testing removeSingleConstraintInfo', () => {
       const ast = parse(code)
       if (err(ast)) throw ast
 
-      const programMemory = await enginelessExecutor(ast)
+      const execState = await enginelessExecutor(ast)
       const lineOfInterest = expectedFinish.split('(')[0] + '('
       const range: [number, number] = [
         code.indexOf(lineOfInterest) + 1,
@@ -661,7 +661,7 @@ describe('Testing removeSingleConstraintInfo', () => {
         pathToNode,
         argPosition,
         ast,
-        programMemory
+        execState.memory
       )
       if (!mod) return new Error('mod is undefined')
       const recastCode = recast(mod.modifiedAst)
@@ -686,7 +686,7 @@ describe('Testing removeSingleConstraintInfo', () => {
       const ast = parse(code)
       if (err(ast)) throw ast
 
-      const programMemory = await enginelessExecutor(ast)
+      const execState = await enginelessExecutor(ast)
       const lineOfInterest = expectedFinish.split('(')[0] + '('
       const range: [number, number] = [
         code.indexOf(lineOfInterest) + 1,
@@ -711,7 +711,7 @@ describe('Testing removeSingleConstraintInfo', () => {
         pathToNode,
         argPosition,
         ast,
-        programMemory
+        execState.memory
       )
       if (!mod) return new Error('mod is undefined')
       const recastCode = recast(mod.modifiedAst)
@@ -882,7 +882,7 @@ sketch002 = startSketchOn({
       // const lineOfInterest = 'line([-2.94, 2.7], %)'
       const ast = parse(codeBefore)
       if (err(ast)) throw ast
-      const programMemory = await enginelessExecutor(ast)
+      const execState = await enginelessExecutor(ast)
 
       // deleteFromSelection
       const range: [number, number] = [
@@ -895,7 +895,7 @@ sketch002 = startSketchOn({
           range,
           type,
         },
-        programMemory,
+        execState.memory,
         async () => {
           await new Promise((resolve) => setTimeout(resolve, 100))
           return {

src/lang/modifyAst.ts

@@ -501,6 +501,7 @@ export function sketchOnExtrudedFace(
       createIdentifier(extrudeName ? extrudeName : oldSketchName),
       _tag,
     ]),
+    undefined,
     'const'
   )
 
@@ -682,6 +683,7 @@ export function createPipeExpression(
 export function createVariableDeclaration(
   varName: string,
   init: VariableDeclarator['init'],
+  visibility: VariableDeclaration['visibility'] = 'default',
   kind: VariableDeclaration['kind'] = 'const'
 ): VariableDeclaration {
   return {
@@ -699,6 +701,7 @@ export function createVariableDeclaration(
         init,
       },
     ],
+    visibility,
     kind,
   }
 }

src/lang/modifyAst/addFillet.test.ts

@@ -620,7 +620,7 @@ describe('Testing button states', () => {
   it('should return true when body exists and segment is selected', async () => {
     await runButtonStateTest(codeWithBody, `line([10, 0], %)`, true)
   })
-  it('hould return false when body exists and not a segment is selected', async () => {
+  it('should return false when body exists and not a segment is selected', async () => {
     await runButtonStateTest(codeWithBody, `close(%)`, false)
   })
 })

src/lang/modifyAst/addFillet.ts

@@ -1,5 +1,7 @@
 import {
   CallExpression,
+  Expr,
+  Identifier,
   ObjectExpression,
   PathToNode,
   Program,
@@ -27,7 +29,7 @@ import {
   sketchLineHelperMap,
 } from '../std/sketch'
 import { err, trap } from 'lib/trap'
-import { Selections, canFilletSelection } from 'lib/selections'
+import { Selections } from 'lib/selections'
 import { KclCommandValue } from 'lib/commandTypes'
 import {
   ArtifactGraph,
@@ -66,7 +68,10 @@ export function modifyAstCloneWithFilletAndTag(
   const artifactGraph = engineCommandManager.artifactGraph
 
   // Step 1: modify ast with tags and group them by extrude nodes (bodies)
-  const extrudeToTagsMap: Map<PathToNode, string[]> = new Map()
+  const extrudeToTagsMap: Map<
+    PathToNode,
+    Array<{ tag: string; selectionType: string }>
+  > = new Map()
   const lookupMap: Map<string, PathToNode> = new Map() // work around for Map key comparison
 
   for (const selectionRange of selection.codeBasedSelections) {
@@ -74,6 +79,7 @@ export function modifyAstCloneWithFilletAndTag(
       codeBasedSelections: [selectionRange],
       otherSelections: [],
     }
+    const selectionType = singleSelection.codeBasedSelections[0].type
 
     const result = getPathToExtrudeForSegmentSelection(
       clonedAstForGetExtrude,
@@ -89,6 +95,7 @@ export function modifyAstCloneWithFilletAndTag(
     )
     if (err(tagResult)) return tagResult
     const { tag } = tagResult
+    const tagInfo = { tag, selectionType }
 
     // Group tags by their corresponding extrude node
     const extrudeKey = JSON.stringify(pathToExtrudeNode)
@@ -96,23 +103,29 @@ export function modifyAstCloneWithFilletAndTag(
     if (lookupMap.has(extrudeKey)) {
       const existingPath = lookupMap.get(extrudeKey)
       if (!existingPath) return new Error('Path to extrude node not found.')
-      extrudeToTagsMap.get(existingPath)?.push(tag)
+      extrudeToTagsMap.get(existingPath)?.push(tagInfo)
     } else {
       lookupMap.set(extrudeKey, pathToExtrudeNode)
-      extrudeToTagsMap.set(pathToExtrudeNode, [tag])
+      extrudeToTagsMap.set(pathToExtrudeNode, [tagInfo])
     }
   }
 
   // Step 2: Apply fillet(s) for each extrude node (body)
   let pathToFilletNodes: Array<PathToNode> = []
-  for (const [pathToExtrudeNode, tags] of extrudeToTagsMap.entries()) {
+  for (const [pathToExtrudeNode, tagInfos] of extrudeToTagsMap.entries()) {
     // Create a fillet expression with multiple tags
     const radiusValue =
       'variableName' in radius ? radius.variableIdentifierAst : radius.valueAst
+
+    const tagCalls = tagInfos.map(({ tag, selectionType }) => {
+      return getEdgeTagCall(tag, selectionType)
+    })
+    const firstTag = tagCalls[0] // can be Identifier or CallExpression (for opposite and adjacent edges)
+
     const filletCall = createCallExpressionStdLib('fillet', [
       createObjectExpression({
         radius: radiusValue,
-        tags: createArrayExpression(tags.map((tag) => createIdentifier(tag))),
+        tags: createArrayExpression(tagCalls),
       }),
       createPipeSubstitution(),
     ])
@@ -144,7 +157,7 @@ export function modifyAstCloneWithFilletAndTag(
       pathToFilletNode = getPathToNodeOfFilletLiteral(
         pathToExtrudeNode,
         extrudeDeclarator,
-        tags[0]
+        firstTag
       )
       pathToFilletNodes.push(pathToFilletNode)
     } else if (extrudeDeclarator.init.type === 'PipeExpression') {
@@ -165,7 +178,7 @@ export function modifyAstCloneWithFilletAndTag(
       pathToFilletNode = getPathToNodeOfFilletLiteral(
         pathToExtrudeNode,
         extrudeDeclarator,
-        tags[0]
+        firstTag
       )
       pathToFilletNodes.push(pathToFilletNode)
     } else {
@@ -276,6 +289,21 @@ function mutateAstWithTagForSketchSegment(
   return { modifiedAst: astClone, tag }
 }
 
+function getEdgeTagCall(
+  tag: string,
+  selectionType: string
+): Identifier | CallExpression {
+  let tagCall: Expr = createIdentifier(tag)
+
+  // Modify the tag based on selectionType
+  if (selectionType === 'edge') {
+    tagCall = createCallExpressionStdLib('getOppositeEdge', [tagCall])
+  } else if (selectionType === 'adjacent-edge') {
+    tagCall = createCallExpressionStdLib('getNextAdjacentEdge', [tagCall])
+  }
+  return tagCall
+}
+
 function locateExtrudeDeclarator(
   node: Program,
   pathToExtrudeNode: PathToNode
@@ -311,7 +339,7 @@ function locateExtrudeDeclarator(
 function getPathToNodeOfFilletLiteral(
   pathToExtrudeNode: PathToNode,
   extrudeDeclarator: VariableDeclarator,
-  tag: string
+  tag: Identifier | CallExpression
 ): PathToNode {
   let pathToFilletObj: PathToNode = []
   let inFillet = false
@@ -347,12 +375,30 @@ function getPathToNodeOfFilletLiteral(
   ]
 }
 
-function hasTag(node: ObjectExpression, tag: string): boolean {
+function hasTag(
+  node: ObjectExpression,
+  tag: Identifier | CallExpression
+): boolean {
   return node.properties.some((prop) => {
     if (prop.key.name === 'tags' && prop.value.type === 'ArrayExpression') {
-      return prop.value.elements.some(
-        (element) => element.type === 'Identifier' && element.name === tag
-      )
+      // if selection is a base edge:
+      if (tag.type === 'Identifier') {
+        return prop.value.elements.some(
+          (element) =>
+            element.type === 'Identifier' && element.name === tag.name
+        )
+      }
+      // if selection is an adjacent or opposite edge:
+      if (tag.type === 'CallExpression') {
+        return prop.value.elements.some(
+          (element) =>
+            element.type === 'CallExpression' &&
+            element.callee.name === tag.callee.name && // edge location
+            element.arguments[0].type === 'Identifier' &&
+            tag.arguments[0].type === 'Identifier' &&
+            element.arguments[0].name === tag.arguments[0].name // tag name
+        )
+      }
     }
     return false
   })
@@ -383,7 +429,7 @@ export const hasValidFilletSelection = ({
   ast: Program
   code: string
 }) => {
-  // case 0: check if there is anything filletable in the scene
+  // check if there is anything filletable in the scene
   let extrudeExists = false
   traverse(ast, {
     enter(node) {
@@ -394,65 +440,88 @@ export const hasValidFilletSelection = ({
   })
   if (!extrudeExists) return false
 
-  // case 1: nothing selected, test whether the extrusion exists
-  if (selectionRanges) {
-    if (selectionRanges.codeBasedSelections.length === 0) {
-      return true
-    }
-    const range0 = selectionRanges.codeBasedSelections[0].range[0]
-    const codeLength = code.length
-    if (range0 === codeLength) {
-      return true
-    }
+  // check if nothing is selected
+  if (selectionRanges.codeBasedSelections.length === 0) {
+    return true
   }
 
-  // case 2: sketch segment selected, test whether it is extruded
-  // TODO: add loft / sweep check
-  if (selectionRanges.codeBasedSelections.length > 0) {
-    const isExtruded = hasSketchPipeBeenExtruded(
-      selectionRanges.codeBasedSelections[0],
-      ast
+  // check if selection is last string in code
+  if (selectionRanges.codeBasedSelections[0].range[0] === code.length) {
+    return true
+  }
+
+  // selection exists:
+  for (const selection of selectionRanges.codeBasedSelections) {
+    // check if all selections are in sketchLineHelperMap
+    const path = getNodePathFromSourceRange(ast, selection.range)
+    const segmentNode = getNodeFromPath<CallExpression>(
+      ast,
+      path,
+      'CallExpression'
     )
-    if (isExtruded) {
-      const pathToSelectedNode = getNodePathFromSourceRange(
-        ast,
-        selectionRanges.codeBasedSelections[0].range
-      )
-      const segmentNode = getNodeFromPath<CallExpression>(
-        ast,
-        pathToSelectedNode,
-        'CallExpression'
-      )
-      if (err(segmentNode)) return false
-      if (segmentNode.node.type === 'CallExpression') {
-        const segmentName = segmentNode.node.callee.name
-        if (segmentName in sketchLineHelperMap) {
-          // Add check whether the tag exists at all:
-          if (!(segmentNode.node.arguments.length === 3)) return true
-          // If the tag exists, check if it is already filleted
-          const edges = isTagUsedInFillet({
-            ast,
-            callExp: segmentNode.node,
-          })
-          // edge has already been filleted
-          if (
-            ['edge', 'default'].includes(
-              selectionRanges.codeBasedSelections[0].type
-            ) &&
-            edges.includes('baseEdge')
-          )
-            return false
-          return true
-        } else {
-          return false
-        }
-      }
-    } else {
+    if (err(segmentNode)) return false
+    if (segmentNode.node.type !== 'CallExpression') {
+      return false
+    }
+    if (!(segmentNode.node.callee.name in sketchLineHelperMap)) {
       return false
     }
-  }
 
-  return canFilletSelection(selectionRanges)
+    // check if selection is extruded
+    // TODO: option 1 : extrude is in the sketch pipe
+
+    // option 2: extrude is outside the sketch pipe
+    const extrudeExists = hasSketchPipeBeenExtruded(selection, ast)
+    if (err(extrudeExists)) {
+      return false
+    }
+    if (!extrudeExists) {
+      return false
+    }
+
+    // check if tag exists for the selection
+    let tagExists = false
+    let tag = ''
+    traverse(segmentNode.node, {
+      enter(node) {
+        if (node.type === 'TagDeclarator') {
+          tagExists = true
+          tag = node.value
+        }
+      },
+    })
+
+    // check if tag is used in fillet
+    if (tagExists) {
+      // create tag call
+      let tagCall: Expr = getEdgeTagCall(tag, selection.type)
+
+      // check if tag is used in fillet
+      let inFillet = false
+      let tagUsedInFillet = false
+      traverse(ast, {
+        enter(node) {
+          if (node.type === 'CallExpression' && node.callee.name === 'fillet') {
+            inFillet = true
+          }
+          if (inFillet && node.type === 'ObjectExpression') {
+            if (hasTag(node, tagCall)) {
+              tagUsedInFillet = true
+            }
+          }
+        },
+        leave(node) {
+          if (node.type === 'CallExpression' && node.callee.name === 'fillet') {
+            inFillet = false
+          }
+        },
+      })
+      if (tagUsedInFillet) {
+        return false
+      }
+    }
+  }
+  return true
 }
 
 type EdgeTypes =

src/lang/queryAst.test.ts

@@ -45,11 +45,11 @@ variableBelowShouldNotBeIncluded = 3
     const rangeStart = code.indexOf('// selection-range-7ish-before-this') - 7
     const ast = parse(code)
     if (err(ast)) throw ast
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
 
     const { variables, bodyPath, insertIndex } = findAllPreviousVariables(
       ast,
-      programMemory,
+      execState.memory,
       [rangeStart, rangeStart]
     )
     expect(variables).toEqual([
@@ -351,11 +351,11 @@ part001 = startSketchAt([-1.41, 3.46])
     const ast = parse(exampleCode)
     if (err(ast)) throw ast
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const result = hasExtrudeSketch({
       ast,
       selection: { type: 'default', range: [100, 101] },
-      programMemory,
+      programMemory: execState.memory,
     })
     expect(result).toEqual(true)
   })
@@ -370,11 +370,11 @@ part001 = startSketchAt([-1.41, 3.46])
     const ast = parse(exampleCode)
     if (err(ast)) throw ast
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const result = hasExtrudeSketch({
       ast,
       selection: { type: 'default', range: [100, 101] },
-      programMemory,
+      programMemory: execState.memory,
     })
     expect(result).toEqual(true)
   })
@@ -383,11 +383,11 @@ part001 = startSketchAt([-1.41, 3.46])
     const ast = parse(exampleCode)
     if (err(ast)) throw ast
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const result = hasExtrudeSketch({
       ast,
       selection: { type: 'default', range: [10, 11] },
-      programMemory,
+      programMemory: execState.memory,
     })
     expect(result).toEqual(false)
   })

src/lang/queryAst.ts

@@ -28,6 +28,7 @@ import {
   getConstraintType,
 } from './std/sketchcombos'
 import { err } from 'lib/trap'
+import { ImportStatement } from 'wasm-lib/kcl/bindings/ImportStatement'
 
 /**
  * Retrieves a node from a given path within a Program node structure, optionally stopping at a specified node type.
@@ -120,7 +121,12 @@ export function getNodeFromPathCurry(
 }
 
 function moreNodePathFromSourceRange(
-  node: Expr | ExpressionStatement | VariableDeclaration | ReturnStatement,
+  node:
+    | Expr
+    | ImportStatement
+    | ExpressionStatement
+    | VariableDeclaration
+    | ReturnStatement,
   sourceRange: Selection['range'],
   previousPath: PathToNode = [['body', '']]
 ): PathToNode {

src/lang/std/sketch.test.ts

@@ -117,11 +117,11 @@ describe('testing changeSketchArguments', () => {
     const ast = parse(code)
     if (err(ast)) return ast
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const sourceStart = code.indexOf(lineToChange)
     const changeSketchArgsRetVal = changeSketchArguments(
       ast,
-      programMemory,
+      execState.memory,
       {
         type: 'sourceRange',
         sourceRange: [sourceStart, sourceStart + lineToChange.length],
@@ -150,12 +150,12 @@ mySketch001 = startSketchOn('XY')
     const ast = parse(code)
     if (err(ast)) return ast
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const sourceStart = code.indexOf(lineToChange)
     expect(sourceStart).toBe(89)
     const newSketchLnRetVal = addNewSketchLn({
       node: ast,
-      programMemory,
+      programMemory: execState.memory,
       input: {
         type: 'straight-segment',
         from: [0, 0],
@@ -186,7 +186,7 @@ mySketch001 = startSketchOn('XY')
 
     const modifiedAst2 = addCloseToPipe({
       node: ast,
-      programMemory,
+      programMemory: execState.memory,
       pathToNode: [
         ['body', ''],
         [0, 'index'],
@@ -230,7 +230,7 @@ describe('testing addTagForSketchOnFace', () => {
     const pathToNode = getNodePathFromSourceRange(ast, sourceRange)
     const sketchOnFaceRetVal = addTagForSketchOnFace(
       {
-        // previousProgramMemory: programMemory, // redundant?
+        // previousProgramMemory: execState.memory, // redundant?
         pathToNode,
         node: ast,
       },

src/lang/std/sketchConstraints.test.ts

@@ -34,7 +34,7 @@ async function testingSwapSketchFnCall({
   const ast = parse(inputCode)
   if (err(ast)) return Promise.reject(ast)
 
-  const programMemory = await enginelessExecutor(ast)
+  const execState = await enginelessExecutor(ast)
   const selections = {
     codeBasedSelections: [range],
     otherSelections: [],
@@ -45,7 +45,7 @@ async function testingSwapSketchFnCall({
     return Promise.reject(new Error('transformInfos undefined'))
   const ast2 = transformAstSketchLines({
     ast,
-    programMemory,
+    programMemory: execState.memory,
     selectionRanges: selections,
     transformInfos,
     referenceSegName: '',
@@ -360,10 +360,10 @@ part001 = startSketchOn('XY')
   |> line([2.14, 1.35], %) // normal-segment
   |> xLine(3.54, %)`
   it('normal case works', async () => {
-    const programMemory = await enginelessExecutor(parse(code))
+    const execState = await enginelessExecutor(parse(code))
     const index = code.indexOf('// normal-segment') - 7
     const sg = sketchFromKclValue(
-      programMemory.get('part001'),
+      execState.memory.get('part001'),
       'part001'
     ) as Sketch
     const _segment = getSketchSegmentFromSourceRange(sg, [index, index])
@@ -377,10 +377,10 @@ part001 = startSketchOn('XY')
     })
   })
   it('verify it works when the segment is in the `start` property', async () => {
-    const programMemory = await enginelessExecutor(parse(code))
+    const execState = await enginelessExecutor(parse(code))
     const index = code.indexOf('// segment-in-start') - 7
     const _segment = getSketchSegmentFromSourceRange(
-      sketchFromKclValue(programMemory.get('part001'), 'part001') as Sketch,
+      sketchFromKclValue(execState.memory.get('part001'), 'part001') as Sketch,
       [index, index]
     )
     if (err(_segment)) throw _segment

src/lang/std/sketchcombos.test.ts

@@ -9,7 +9,7 @@ import {
   getConstraintLevelFromSourceRange,
 } from './sketchcombos'
 import { ToolTip } from 'lang/langHelpers'
-import { Selections } from 'lib/selections'
+import { Selection, Selections } from 'lib/selections'
 import { err } from 'lib/trap'
 import { enginelessExecutor } from '../../lib/testHelpers'
 
@@ -96,6 +96,86 @@ function makeSelections(
 }
 
 describe('testing transformAstForSketchLines for equal length constraint', () => {
+  describe(`should always reorder selections to have the base selection first`, () => {
+    const inputScript = `sketch001 = startSketchOn('XZ')
+  |> startProfileAt([0, 0], %)
+  |> line([5, 5], %)
+  |> line([-2, 5], %)
+  |> lineTo([profileStartX(%), profileStartY(%)], %)
+  |> close(%)`
+
+    const expectedModifiedScript = `sketch001 = startSketchOn('XZ')
+  |> startProfileAt([0, 0], %)
+  |> line([5, 5], %, $seg01)
+  |> angledLine([112, segLen(seg01)], %)
+  |> lineTo([profileStartX(%), profileStartY(%)], %)
+  |> close(%)
+`
+
+    const selectLine = (script: string, lineNumber: number): Selection => {
+      const lines = script.split('\n')
+      const codeBeforeLine = lines.slice(0, lineNumber).join('\n').length
+      const line = lines.find((_, i) => i === lineNumber)
+      if (!line) {
+        throw new Error(
+          `line index ${lineNumber} not found in test sample, friend`
+        )
+      }
+      const start = codeBeforeLine + line.indexOf('|> ' + 5)
+      const range: [number, number] = [start, start]
+      return {
+        type: 'default',
+        range,
+      }
+    }
+
+    async function applyTransformation(
+      inputCode: string,
+      selectionRanges: Selections['codeBasedSelections']
+    ) {
+      const ast = parse(inputCode)
+      if (err(ast)) return Promise.reject(ast)
+      const execState = await enginelessExecutor(ast)
+      const transformInfos = getTransformInfos(
+        makeSelections(selectionRanges.slice(1)),
+        ast,
+        'equalLength'
+      )
+
+      const transformedSelection = makeSelections(selectionRanges)
+
+      const newAst = transformSecondarySketchLinesTagFirst({
+        ast,
+        selectionRanges: transformedSelection,
+        transformInfos,
+        programMemory: execState.memory,
+      })
+      if (err(newAst)) return Promise.reject(newAst)
+
+      const newCode = recast(newAst.modifiedAst)
+      return newCode
+    }
+
+    it(`Should reorder when user selects first-to-last`, async () => {
+      const selectionRanges: Selections['codeBasedSelections'] = [
+        selectLine(inputScript, 3),
+        selectLine(inputScript, 4),
+      ]
+
+      const newCode = await applyTransformation(inputScript, selectionRanges)
+      expect(newCode).toBe(expectedModifiedScript)
+    })
+
+    it(`Should reorder when user selects last-to-first`, async () => {
+      const selectionRanges: Selections['codeBasedSelections'] = [
+        selectLine(inputScript, 4),
+        selectLine(inputScript, 3),
+      ]
+
+      const newCode = await applyTransformation(inputScript, selectionRanges)
+      expect(newCode).toBe(expectedModifiedScript)
+    })
+  })
   const inputScript = `myVar = 3
 myVar2 = 5
 myVar3 = 6
@@ -220,7 +300,7 @@ part001 = startSketchOn('XY')
         }
       })
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const transformInfos = getTransformInfos(
       makeSelections(selectionRanges.slice(1)),
       ast,
@@ -231,7 +311,7 @@ part001 = startSketchOn('XY')
       ast,
       selectionRanges: makeSelections(selectionRanges),
       transformInfos,
-      programMemory,
+      programMemory: execState.memory,
     })
     if (err(newAst)) return Promise.reject(newAst)
 
@@ -311,7 +391,7 @@ part001 = startSketchOn('XY')
         }
       })
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const transformInfos = getTransformInfos(
       makeSelections(selectionRanges),
       ast,
@@ -322,7 +402,7 @@ part001 = startSketchOn('XY')
       ast,
       selectionRanges: makeSelections(selectionRanges),
       transformInfos,
-      programMemory,
+      programMemory: execState.memory,
       referenceSegName: '',
     })
     if (err(newAst)) return Promise.reject(newAst)
@@ -373,7 +453,7 @@ part001 = startSketchOn('XY')
         }
       })
 
-    const programMemory = await enginelessExecutor(ast)
+    const execState = await enginelessExecutor(ast)
     const transformInfos = getTransformInfos(
       makeSelections(selectionRanges),
       ast,
@@ -384,7 +464,7 @@ part001 = startSketchOn('XY')
       ast,
       selectionRanges: makeSelections(selectionRanges),
       transformInfos,
-      programMemory,
+      programMemory: execState.memory,
       referenceSegName: '',
     })
     if (err(newAst)) return Promise.reject(newAst)
@@ -470,7 +550,7 @@ async function helperThing(
       }
     })
 
-  const programMemory = await enginelessExecutor(ast)
+  const execState = await enginelessExecutor(ast)
   const transformInfos = getTransformInfos(
     makeSelections(selectionRanges.slice(1)),
     ast,
@@ -481,7 +561,7 @@ async function helperThing(
     ast,
     selectionRanges: makeSelections(selectionRanges),
     transformInfos,
-    programMemory,
+    programMemory: execState.memory,
   })
 
   if (err(newAst)) return Promise.reject(newAst)

src/lang/std/sketchcombos.ts

@@ -1559,7 +1559,15 @@ export function transformSecondarySketchLinesTagFirst({
     }
   | Error {
   // let node = structuredClone(ast)
-  const primarySelection = selectionRanges.codeBasedSelections[0].range
+
+  // We need to sort the selections by their start position
+  // so that we can process them in dependency order and not write invalid KCL.
+  const sortedCodeBasedSelections =
+    selectionRanges.codeBasedSelections.toSorted(
+      (a, b) => a.range[0] - b.range[0]
+    )
+  const primarySelection = sortedCodeBasedSelections[0].range
+  const secondarySelections = sortedCodeBasedSelections.slice(1)
 
   const _tag = giveSketchFnCallTag(ast, primarySelection, forceSegName)
   if (err(_tag)) return _tag
@@ -1569,7 +1577,7 @@ export function transformSecondarySketchLinesTagFirst({
     ast: modifiedAst,
     selectionRanges: {
       ...selectionRanges,
-      codeBasedSelections: selectionRanges.codeBasedSelections.slice(1),
+      codeBasedSelections: secondarySelections,
     },
     referencedSegmentRange: primarySelection,
     transformInfos,

src/lang/std/std.test.ts

@@ -17,9 +17,9 @@ describe('testing angledLineThatIntersects', () => {
   offset: ${offset},
 }, %, $yo2)
 intersect = segEndX(yo2)`
-    const mem = await enginelessExecutor(parse(code('-1')))
-    expect(mem.get('intersect')?.value).toBe(1 + Math.sqrt(2))
+    const execState = await enginelessExecutor(parse(code('-1')))
+    expect(execState.memory.get('intersect')?.value).toBe(1 + Math.sqrt(2))
     const noOffset = await enginelessExecutor(parse(code('0')))
-    expect(noOffset.get('intersect')?.value).toBeCloseTo(1)
+    expect(noOffset.memory.get('intersect')?.value).toBeCloseTo(1)
   })
 })

src/lang/wasm.ts

@@ -37,6 +37,11 @@ import { Configuration } from 'wasm-lib/kcl/bindings/Configuration'
 import { DeepPartial } from 'lib/types'
 import { ProjectConfiguration } from 'wasm-lib/kcl/bindings/ProjectConfiguration'
 import { Sketch } from '../wasm-lib/kcl/bindings/Sketch'
+import { IdGenerator } from 'wasm-lib/kcl/bindings/IdGenerator'
+import { ExecState as RawExecState } from '../wasm-lib/kcl/bindings/ExecState'
+import { ProgramMemory as RawProgramMemory } from '../wasm-lib/kcl/bindings/ProgramMemory'
+import { EnvironmentRef } from '../wasm-lib/kcl/bindings/EnvironmentRef'
+import { Environment } from '../wasm-lib/kcl/bindings/Environment'
 
 export type { Program } from '../wasm-lib/kcl/bindings/Program'
 export type { Expr } from '../wasm-lib/kcl/bindings/Expr'
@@ -136,29 +141,46 @@ export const parse = (code: string | Error): Program | Error => {
 
 export type PathToNode = [string | number, string][]
 
-interface Memory {
-  [key: string]: KclValue
+export interface ExecState {
+  memory: ProgramMemory
+  idGenerator: IdGenerator
 }
 
-type EnvironmentRef = number
+/**
+ * Create an empty ExecState.  This is useful on init to prevent needing an
+ * Option.
+ */
+export function emptyExecState(): ExecState {
+  return {
+    memory: ProgramMemory.empty(),
+    idGenerator: defaultIdGenerator(),
+  }
+}
+
+function execStateFromRaw(raw: RawExecState): ExecState {
+  return {
+    memory: ProgramMemory.fromRaw(raw.memory),
+    idGenerator: raw.idGenerator,
+  }
+}
+
+export function defaultIdGenerator(): IdGenerator {
+  return {
+    nextId: 0,
+    ids: [],
+  }
+}
+
+interface Memory {
+  [key: string]: KclValue | undefined
+}
 
 const ROOT_ENVIRONMENT_REF: EnvironmentRef = 0
 
-interface Environment {
-  bindings: Memory
-  parent: EnvironmentRef | null
-}
-
 function emptyEnvironment(): Environment {
   return { bindings: {}, parent: null }
 }
 
-interface RawProgramMemory {
-  environments: Environment[]
-  currentEnv: EnvironmentRef
-  return: KclValue | null
-}
-
 /**
  * This duplicates logic in Rust.  The hope is to keep ProgramMemory internals
  * isolated from the rest of the TypeScript code so that we can move it to Rust
@@ -217,7 +239,7 @@ export class ProgramMemory {
     while (true) {
       const env = this.environments[envRef]
       if (env.bindings.hasOwnProperty(name)) {
-        return env.bindings[name]
+        return env.bindings[name] ?? null
       }
       if (!env.parent) {
         break
@@ -260,6 +282,7 @@ export class ProgramMemory {
       }
 
       for (const [name, value] of Object.entries(env.bindings)) {
+        if (value === undefined) continue
         // Check the predicate.
         if (!predicate(value)) {
           continue
@@ -293,6 +316,7 @@ export class ProgramMemory {
     while (true) {
       const env = this.environments[envRef]
       for (const [name, value] of Object.entries(env.bindings)) {
+        if (value === undefined) continue
         // Don't include shadowed variables.
         if (!map.has(name)) {
           map.set(name, value)
@@ -356,9 +380,10 @@ export function sketchFromKclValue(
 export const executor = async (
   node: Program,
   programMemory: ProgramMemory | Error = ProgramMemory.empty(),
+  idGenerator: IdGenerator = defaultIdGenerator(),
   engineCommandManager: EngineCommandManager,
   isMock: boolean = false
-): Promise<ProgramMemory> => {
+): Promise<ExecState> => {
   if (err(programMemory)) return Promise.reject(programMemory)
 
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
@@ -366,6 +391,7 @@ export const executor = async (
   const _programMemory = await _executor(
     node,
     programMemory,
+    idGenerator,
     engineCommandManager,
     isMock
   )
@@ -378,9 +404,10 @@ export const executor = async (
 export const _executor = async (
   node: Program,
   programMemory: ProgramMemory | Error = ProgramMemory.empty(),
+  idGenerator: IdGenerator = defaultIdGenerator(),
   engineCommandManager: EngineCommandManager,
   isMock: boolean
-): Promise<ProgramMemory> => {
+): Promise<ExecState> => {
   if (err(programMemory)) return Promise.reject(programMemory)
 
   try {
@@ -392,15 +419,17 @@ export const _executor = async (
       baseUnit =
         (await getSettingsState)()?.modeling.defaultUnit.current || 'mm'
     }
-    const memory: RawProgramMemory = await execute_wasm(
+    const execState: RawExecState = await execute_wasm(
       JSON.stringify(node),
       JSON.stringify(programMemory.toRaw()),
+      JSON.stringify(idGenerator),
       baseUnit,
       engineCommandManager,
       fileSystemManager,
+      undefined,
       isMock
     )
-    return ProgramMemory.fromRaw(memory)
+    return execStateFromRaw(execState)
   } catch (e: any) {
     console.log(e)
     const parsed: RustKclError = JSON.parse(e.toString())

src/lib/constants.ts

@@ -102,3 +102,6 @@ export const KCL_SAMPLES_MANIFEST_URLS = {
     'https://raw.githubusercontent.com/KittyCAD/kcl-samples/main/manifest.json',
   localFallback: '/kcl-samples-manifest-fallback.json',
 } as const
+
+/** Toast id for the app auto-updater toast */
+export const AUTO_UPDATER_TOAST_ID = 'auto-updater-toast'

src/lib/machine-api.d.ts

@@ -55,6 +55,23 @@ export interface paths {
     patch?: never
     trace?: never
   }
+  '/metrics': {
+    parameters: {
+      query?: never
+      header?: never
+      path?: never
+      cookie?: never
+    }
+    /** List available machines and their statuses */
+    get: operations['get_metrics']
+    put?: never
+    post?: never
+    delete?: never
+    options?: never
+    head?: never
+    patch?: never
+    trace?: never
+  }
   '/ping': {
     parameters: {
       query?: never
@@ -278,6 +295,28 @@ export interface operations {
       '5XX': components['responses']['Error']
     }
   }
+  get_metrics: {
+    parameters: {
+      query?: never
+      header?: never
+      path?: never
+      cookie?: never
+    }
+    requestBody?: never
+    responses: {
+      /** @description successful operation */
+      200: {
+        headers: {
+          [name: string]: unknown
+        }
+        content: {
+          'application/json': string
+        }
+      }
+      '4XX': components['responses']['Error']
+      '5XX': components['responses']['Error']
+    }
+  }
   ping: {
     parameters: {
       query?: never

src/lib/testHelpers.ts

@@ -1,4 +1,11 @@
-import { Program, ProgramMemory, _executor, SourceRange } from '../lang/wasm'
+import {
+  Program,
+  ProgramMemory,
+  _executor,
+  SourceRange,
+  ExecState,
+  defaultIdGenerator,
+} from '../lang/wasm'
 import {
   EngineCommandManager,
   EngineCommandManagerEvents,
@@ -9,6 +16,7 @@ import { v4 as uuidv4 } from 'uuid'
 import { DefaultPlanes } from 'wasm-lib/kcl/bindings/DefaultPlanes'
 import { err, reportRejection } from 'lib/trap'
 import { toSync } from './utils'
+import { IdGenerator } from 'wasm-lib/kcl/bindings/IdGenerator'
 
 type WebSocketResponse = Models['WebSocketResponse_type']
 
@@ -77,8 +85,9 @@ class MockEngineCommandManager {
 
 export async function enginelessExecutor(
   ast: Program | Error,
-  pm: ProgramMemory | Error = ProgramMemory.empty()
-): Promise<ProgramMemory> {
+  pm: ProgramMemory | Error = ProgramMemory.empty(),
+  idGenerator: IdGenerator = defaultIdGenerator()
+): Promise<ExecState> {
   if (err(ast)) return Promise.reject(ast)
   if (err(pm)) return Promise.reject(pm)
 
@@ -88,15 +97,22 @@ export async function enginelessExecutor(
   }) as any as EngineCommandManager
   // eslint-disable-next-line @typescript-eslint/no-floating-promises
   mockEngineCommandManager.startNewSession()
-  const programMemory = await _executor(ast, pm, mockEngineCommandManager, true)
+  const execState = await _executor(
+    ast,
+    pm,
+    idGenerator,
+    mockEngineCommandManager,
+    true
+  )
   await mockEngineCommandManager.waitForAllCommands()
-  return programMemory
+  return execState
 }
 
 export async function executor(
   ast: Program,
-  pm: ProgramMemory = ProgramMemory.empty()
-): Promise<ProgramMemory> {
+  pm: ProgramMemory = ProgramMemory.empty(),
+  idGenerator: IdGenerator = defaultIdGenerator()
+): Promise<ExecState> {
   const engineCommandManager = new EngineCommandManager()
   engineCommandManager.start({
     setIsStreamReady: () => {},
@@ -117,14 +133,15 @@ export async function executor(
       toSync(async () => {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         engineCommandManager.startNewSession()
-        const programMemory = await _executor(
+        const execState = await _executor(
           ast,
           pm,
+          idGenerator,
           engineCommandManager,
           false
         )
         await engineCommandManager.waitForAllCommands()
-        resolve(programMemory)
+        resolve(execState)
       }, reportRejection)
     )
   })

src/lib/toolbar.ts

@@ -295,15 +295,24 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
       'break',
       {
         id: 'line',
-        onClick: ({ modelingState, modelingSend }) =>
-          modelingSend({
-            type: 'change tool',
-            data: {
-              tool: !modelingState.matches({ Sketch: 'Line tool' })
-                ? 'line'
-                : 'none',
-            },
-          }),
+        onClick: ({ modelingState, modelingSend }) => {
+          if (modelingState.matches({ Sketch: { 'Line tool': 'No Points' } })) {
+            // Exit the sketch state if there are no points and they press ESC
+            modelingSend({
+              type: 'Cancel',
+            })
+          } else {
+            // Exit the tool if there are points and they press ESC
+            modelingSend({
+              type: 'change tool',
+              data: {
+                tool: !modelingState.matches({ Sketch: 'Line tool' })
+                  ? 'line'
+                  : 'none',
+              },
+            })
+          }
+        },
         icon: 'line',
         status: 'available',
         disabled: (state) =>

src/lib/useCalculateKclExpression.ts

@@ -97,7 +97,7 @@ export function useCalculateKclExpression({
         })
         if (trap(error, { suppress: true })) return
       }
-      const { programMemory } = await executeAst({
+      const { execState } = await executeAst({
         ast,
         engineCommandManager,
         useFakeExecutor: true,
@@ -111,7 +111,7 @@ export function useCalculateKclExpression({
       const init =
         resultDeclaration?.type === 'VariableDeclaration' &&
         resultDeclaration?.declarations?.[0]?.init
-      const result = programMemory?.get('__result__')?.value
+      const result = execState.memory?.get('__result__')?.value
       setCalcResult(typeof result === 'number' ? String(result) : 'NAN')
       init && setValueNode(init)
     }

src/machines/modelingMachine.ts

@@ -666,6 +666,7 @@ export const modelingMachine = setup({
 
         const testExecute = await executeAst({
           ast: modifiedAst,
+          idGenerator: kclManager.execState.idGenerator,
           useFakeExecutor: true,
           engineCommandManager,
         })

src/main.ts

@@ -261,13 +261,36 @@ app.on('ready', () => {
     autoUpdater.checkForUpdates().catch(reportRejection)
   }, fifteenMinutes)
 
+  autoUpdater.on('error', (error) => {
+    console.error('updater-error', error)
+    mainWindow?.webContents.send('updater-error', error)
+  })
+
   autoUpdater.on('update-available', (info) => {
     console.log('update-available', info)
   })
 
+  autoUpdater.prependOnceListener('download-progress', (progress) => {
+    // For now, we'll send nothing and just start a loading spinner.
+    // See below for a TODO to send progress data to the renderer.
+    console.log('update-download-start', {
+      version: '',
+    })
+    mainWindow?.webContents.send('update-download-start', progress)
+  })
+
+  autoUpdater.on('download-progress', (progress) => {
+    // TODO: in a future PR (https://github.com/KittyCAD/modeling-app/issues/3994)
+    // send this data to mainWindow to show a progress bar for the download.
+    console.log('download-progress', progress)
+  })
+
   autoUpdater.on('update-downloaded', (info) => {
     console.log('update-downloaded', info)
-    mainWindow?.webContents.send('update-downloaded', info.version)
+    mainWindow?.webContents.send('update-downloaded', {
+      version: info.version,
+      releaseNotes: info.releaseNotes,
+    })
   })
 
   ipcMain.handle('app.restart', () => {

src/preload.ts

@@ -16,8 +16,14 @@ const startDeviceFlow = (host: string): Promise<string> =>
   ipcRenderer.invoke('startDeviceFlow', host)
 const loginWithDeviceFlow = (): Promise<string> =>
   ipcRenderer.invoke('loginWithDeviceFlow')
-const onUpdateDownloaded = (callback: (value: string) => void) =>
-  ipcRenderer.on('update-downloaded', (_event, value) => callback(value))
+const onUpdateDownloaded = (
+  callback: (value: { version: string; releaseNotes: string }) => void
+) => ipcRenderer.on('update-downloaded', (_event, value) => callback(value))
+const onUpdateDownloadStart = (
+  callback: (value: { version: string }) => void
+) => ipcRenderer.on('update-download-start', (_event, value) => callback(value))
+const onUpdateError = (callback: (value: Error) => void) =>
+  ipcRenderer.on('update-error', (_event, value) => callback(value))
 const appRestart = () => ipcRenderer.invoke('app.restart')
 
 const isMac = os.platform() === 'darwin'
@@ -144,6 +150,8 @@ contextBridge.exposeInMainWorld('electron', {
   kittycad,
   listMachines,
   getMachineApiIp,
+  onUpdateDownloadStart,
   onUpdateDownloaded,
+  onUpdateError,
   appRestart,
 })

src/wasm-lib/Cargo.lock

@@ -434,9 +434,9 @@ dependencies = [
 
 [[package]]
 name = "clap"
-version = "4.5.19"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7be5744db7978a28d9df86a214130d106a89ce49644cbc4e3f0c22c3fba30615"
+checksum = "b97f376d85a664d5837dbae44bf546e6477a679ff6610010f17276f686d867e8"
 dependencies = [
  "clap_builder",
  "clap_derive",
@@ -444,9 +444,9 @@ dependencies = [
 
 [[package]]
 name = "clap_builder"
-version = "4.5.19"
+version = "4.5.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5fbc17d3ef8278f55b282b2a2e75ae6f6c7d4bb70ed3d0382375104bfafdb4b"
+checksum = "19bc80abd44e4bed93ca373a0704ccbd1b710dc5749406201bb018272808dc54"
 dependencies = [
  "anstream",
  "anstyle",
@@ -1394,9 +1394,9 @@ dependencies = [
 
 [[package]]
 name = "image"
-version = "0.25.2"
+version = "0.25.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99314c8a2152b8ddb211f924cdae532d8c5e4c8bb54728e12fff1b0cd5963a10"
+checksum = "d97eb9a8e0cd5b76afea91d7eecd5cf8338cd44ced04256cf1f800474b227c52"
 dependencies = [
  "bytemuck",
  "byteorder-lite",
@@ -1533,16 +1533,16 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "js-sys"
-version = "0.3.70"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1868808506b929d7b0cfa8f75951347aa71bb21144b7791bae35d9bccfcfe37a"
+checksum = "6a88f1bda2bd75b0452a14784937d796722fdebfe50df998aeb3f0b7603019a9"
 dependencies = [
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.20"
+version = "0.2.22"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -1617,7 +1617,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.12"
+version = "0.1.14"
 dependencies = [
  "anyhow",
  "hyper 0.14.30",
@@ -2337,18 +2337,18 @@ dependencies = [
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "7c3a7fc5db1e57d5a779a352c8cdb57b29aa4c40cc69c3a68a7fedc815fbf2f9"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "pyo3"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
+checksum = "3d922163ba1f79c04bc49073ba7b32fd5a8d3b76a87c955921234b8e77333c51"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -2364,9 +2364,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
+checksum = "bc38c5feeb496c8321091edf3d63e9a6829eab4b863b4a6a65f26f3e9cc6b179"
 dependencies = [
  "once_cell",
  "target-lexicon",
@@ -2374,9 +2374,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
+checksum = "94845622d88ae274d2729fcefc850e63d7a3ddff5e3ce11bd88486db9f1d357d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -2384,9 +2384,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
+checksum = "e655aad15e09b94ffdb3ce3d217acf652e26bbc37697ef012f5e5e348c716e5e"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -2396,9 +2396,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
+checksum = "ae1e3f09eecd94618f60a455a23def79f79eba4dc561a97324bf9ac8c6df30ce"
 dependencies = [
  "heck 0.5.0",
  "proc-macro2",
@@ -3829,9 +3829,9 @@ checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
 dependencies = [
  "getrandom",
  "serde",
@@ -3907,9 +3907,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.93"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a82edfc16a6c469f5f44dc7b571814045d60404b55a0ee849f9bcfa2e63dd9b5"
+checksum = "128d1e363af62632b8eb57219c8fd7877144af57558fb2ef0368d0087bddeb2e"
 dependencies = [
  "cfg-if",
  "once_cell",
@@ -3918,9 +3918,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.93"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9de396da306523044d3302746f1208fa71d7532227f15e347e2d93e4145dd77b"
+checksum = "cb6dd4d3ca0ddffd1dd1c9c04f94b868c37ff5fac97c30b97cff2d74fce3a358"
 dependencies = [
  "bumpalo",
  "log",
@@ -3933,9 +3933,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.43"
+version = "0.4.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61e9300f63a621e96ed275155c108eb6f843b6a26d053f122ab69724559dc8ed"
+checksum = "65471f79c1022ffa5291d33520cbbb53b7687b01c2f8e83b57d102eed7ed479d"
 dependencies = [
  "cfg-if",
  "futures-core",
@@ -3946,9 +3946,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.93"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "585c4c91a46b072c92e908d99cb1dcdf95c5218eeb6f3bf1efa991ee7a68cccf"
+checksum = "e79384be7f8f5a9dd5d7167216f022090cf1f9ec128e6e6a482a2cb5c5422c56"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -3956,9 +3956,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.93"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afc340c74d9005395cf9dd098506f7f44e38f2b4a21c6aaacf9a105ea5e1e836"
+checksum = "26c6ab57572f7a24a4985830b120de1594465e5d500f24afe89e16b4e833ef68"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3969,9 +3969,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.93"
+version = "0.2.95"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c62a0a307cb4a311d3a07867860911ca130c3494e8c2719593806c08bc5d0484"
+checksum = "65fc09f10666a9f147042251e0dda9c18f166ff7de300607007e96bdebc1068d"
 
 [[package]]
 name = "wasm-lib"
@@ -4032,9 +4032,9 @@ dependencies = [
 
 [[package]]
 name = "web-sys"
-version = "0.3.70"
+version = "0.3.72"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26fdeaafd9bd129f65e7c031593c24d62186301e0c72c8978fa1678be7d532c0"
+checksum = "f6488b90108c040df0fe62fa815cbdee25124641df01814dd7282749234c6112"
 dependencies = [
  "js-sys",
  "wasm-bindgen",

src/wasm-lib/Cargo.toml

@@ -18,31 +18,31 @@ kittycad.workspace = true
 serde_json = "1.0.128"
 tokio = { version = "1.40.0", features = ["sync"] }
 toml = "0.8.19"
-uuid = { version = "1.10.0", features = ["v4", "js", "serde"] }
+uuid = { version = "1.11.0", features = ["v4", "js", "serde"] }
 wasm-bindgen = "0.2.91"
-wasm-bindgen-futures = "0.4.42"
+wasm-bindgen-futures = "0.4.44"
 
 [dev-dependencies]
 anyhow = "1"
-image = { version = "0.25.1", default-features = false, features = ["png"] }
+image = { version = "0.25.3", default-features = false, features = ["png"] }
 kittycad = { workspace = true, default-features = true }
 kittycad-modeling-cmds = { workspace = true }
 pretty_assertions = "1.4.1"
 reqwest = { version = "0.12", default-features = false }
 tokio = { version = "1.40.0", features = ["rt-multi-thread", "macros", "time"] }
 twenty-twenty = "0.8"
-uuid = { version = "1.10.0", features = ["v4", "js", "serde"] }
+uuid = { version = "1.11.0", features = ["v4", "js", "serde"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1.7"
 futures = "0.3.31"
-js-sys = "0.3.69"
+js-sys = "0.3.72"
 tower-lsp = { version = "0.20.0", default-features = false, features = ["runtime-agnostic"] }
-wasm-bindgen-futures = { version = "0.4.41", features = ["futures-core-03-stream"] }
+wasm-bindgen-futures = { version = "0.4.44", features = ["futures-core-03-stream"] }
 wasm-streams = "0.4.1"
 
 [target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
-version = "0.3.69"
+version = "0.3.72"
 features = [
   "console",
   "HtmlTextAreaElement",

src/wasm-lib/derive-docs/src/lib.rs

@@ -753,6 +753,7 @@ fn generate_code_block_test(fn_name: &str, code_block: &str, index: usize) -> pr
             let tokens = crate::token::lexer(#code_block).unwrap();
             let parser = crate::parser::Parser::new(tokens);
             let program = parser.ast().unwrap();
+            let id_generator = crate::executor::IdGenerator::default();
             let ctx = crate::executor::ExecutorContext {
                 engine: std::sync::Arc::new(Box::new(crate::engine::conn_mock::EngineConnection::new().await.unwrap())),
                 fs: std::sync::Arc::new(crate::fs::FileManager::new()),
@@ -761,7 +762,7 @@ fn generate_code_block_test(fn_name: &str, code_block: &str, index: usize) -> pr
                 context_type: crate::executor::ContextType::Mock,
             };
 
-            ctx.run(&program, None).await.unwrap();
+            ctx.run(&program, None, id_generator, None).await.unwrap();
         }
 
         #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/args_with_lifetime.gen

@@ -5,6 +5,7 @@ mod test_examples_someFn {
         let tokens = crate::token::lexer("someFn()").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_someFn {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/args_with_refs.gen

@@ -5,6 +5,7 @@ mod test_examples_someFn {
         let tokens = crate::token::lexer("someFn()").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_someFn {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/array.gen

@@ -5,6 +5,7 @@ mod test_examples_show {
         let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nshow").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_show {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
@@ -38,6 +39,7 @@ mod test_examples_show {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -49,7 +51,7 @@ mod test_examples_show {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/box.gen

@@ -5,6 +5,7 @@ mod test_examples_show {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_show {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/doc_comment_with_code.gen

@@ -6,6 +6,7 @@ mod test_examples_my_func {
             crate::token::lexer("This is another code block.\nyes sirrr.\nmyFunc").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -17,7 +18,7 @@ mod test_examples_my_func {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
@@ -39,6 +40,7 @@ mod test_examples_my_func {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nmyFunc").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -50,7 +52,7 @@ mod test_examples_my_func {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/lineTo.gen

@@ -6,6 +6,7 @@ mod test_examples_line_to {
             crate::token::lexer("This is another code block.\nyes sirrr.\nlineTo").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -17,7 +18,7 @@ mod test_examples_line_to {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
@@ -39,6 +40,7 @@ mod test_examples_line_to {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nlineTo").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -50,7 +52,7 @@ mod test_examples_line_to {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/min.gen

@@ -5,6 +5,7 @@ mod test_examples_min {
         let tokens = crate::token::lexer("This is another code block.\nyes sirrr.\nmin").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_min {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
@@ -38,6 +39,7 @@ mod test_examples_min {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nmin").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -49,7 +51,7 @@ mod test_examples_min {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/option.gen

@@ -5,6 +5,7 @@ mod test_examples_show {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_show {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/option_input_format.gen

@@ -5,6 +5,7 @@ mod test_examples_import {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_import {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/return_vec_box_sketch.gen

@@ -5,6 +5,7 @@ mod test_examples_import {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_import {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/return_vec_sketch.gen

@@ -5,6 +5,7 @@ mod test_examples_import {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nimport").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_import {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/show.gen

@@ -5,6 +5,7 @@ mod test_examples_show {
         let tokens = crate::token::lexer("This is code.\nIt does other shit.\nshow").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_show {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/derive-docs/tests/test_args_with_exec_state.gen

@@ -5,6 +5,7 @@ mod test_examples_some_function {
         let tokens = crate::token::lexer("someFunction()").unwrap();
         let parser = crate::parser::Parser::new(tokens);
         let program = parser.ast().unwrap();
+        let id_generator = crate::executor::IdGenerator::default();
         let ctx = crate::executor::ExecutorContext {
             engine: std::sync::Arc::new(Box::new(
                 crate::engine::conn_mock::EngineConnection::new()
@@ -16,7 +17,7 @@ mod test_examples_some_function {
             settings: Default::default(),
             context_type: crate::executor::ContextType::Mock,
         };
-        ctx.run(&program, None).await.unwrap();
+        ctx.run(&program, None, id_generator, None).await.unwrap();
     }
 
     #[tokio::test(flavor = "multi_thread", worker_threads = 5)]

src/wasm-lib/kcl-macros/tests/macro_test.rs

@@ -1,7 +1,7 @@
 extern crate alloc;
 use kcl_lib::ast::types::{
-    BodyItem, Expr, Identifier, Literal, LiteralValue, NonCodeMeta, Program, VariableDeclaration, VariableDeclarator,
-    VariableKind,
+    BodyItem, Expr, Identifier, ItemVisibility, Literal, LiteralValue, NonCodeMeta, Program, VariableDeclaration,
+    VariableDeclarator, VariableKind,
 };
 use kcl_macros::parse;
 use pretty_assertions::assert_eq;
@@ -33,6 +33,7 @@ fn basic() {
                 })),
                 digest: None,
             }],
+            visibility: ItemVisibility::Default,
             kind: VariableKind::Const,
             digest: None,
         })],

src/wasm-lib/kcl-test-server/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-test-server"
 description = "A test server for KCL"
-version = "0.1.12"
+version = "0.1.14"
 edition = "2021"
 license = "MIT"
 

src/wasm-lib/kcl-test-server/src/lib.rs

@@ -166,15 +166,19 @@ async fn snapshot_endpoint(body: Bytes, state: ExecutorContext) -> Response<Body
         Err(e) => return bad_request(format!("Parse error: {e}")),
     };
     eprintln!("Executing {test_name}");
+    let mut id_generator = kcl_lib::executor::IdGenerator::default();
     // This is a shitty source range, I don't know what else to use for it though.
     // There's no actual KCL associated with this reset_scene call.
-    if let Err(e) = state.reset_scene(kcl_lib::executor::SourceRange::default()).await {
+    if let Err(e) = state
+        .reset_scene(&mut id_generator, kcl_lib::executor::SourceRange::default())
+        .await
+    {
         return kcl_err(e);
     }
     // Let users know if the test is taking a long time.
     let (done_tx, done_rx) = oneshot::channel::<()>();
     let timer = time_until(done_rx);
-    let snapshot = match state.execute_and_prepare_snapshot(&program).await {
+    let snapshot = match state.execute_and_prepare_snapshot(&program, id_generator, None).await {
         Ok(sn) => sn,
         Err(e) => return kcl_err(e),
     };