Cut release v0.26.2 (#4322)

* Cut release v0.26.2

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

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

---------

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

.codespellrc

@@ -1,3 +1,3 @@
 [codespell]
 ignore-words-list: crate,everytime,inout,co-ordinate,ot,nwo,absolutey,atleast,ue,afterall
-skip: **/target,node_modules,build,**/Cargo.lock,./docs/kcl/*.md,.yarn.lock,**/yarn.lock
+skip: **/target,node_modules,build,**/Cargo.lock,./docs/kcl/*.md,.yarn.lock,**/yarn.lock,./openapi/*.json,./src/lib/machine-api.d.ts

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

@@ -15,6 +15,7 @@ on:
 env:
   CUT_RELEASE_PR: ${{ github.event_name == 'pull_request' && (contains(github.event.pull_request.title, 'Cut release v')) }}
   BUILD_RELEASE: ${{ github.event_name == 'release' || github.event_name == 'schedule' || github.event_name == 'pull_request' && (contains(github.event.pull_request.title, 'Cut release v')) }}
+  NOTES: ${{ github.event_name == 'release' && github.event.release.body || format('Non-release build, commit {0}', github.sha) }}
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
@@ -51,12 +52,20 @@ jobs:
         run: |
           VERSION=$(date +'%-y.%-m.%-d') yarn bump-jsons
 
+      # 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
+        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"
@@ -76,7 +85,7 @@ jobs:
       - 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' }}
@@ -91,7 +100,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 }}
@@ -118,6 +133,7 @@ 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' }}
@@ -173,16 +189,28 @@ jobs:
 
       - uses: actions/upload-artifact@v3
         with:
-          name: out-arm64-${{ 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/Zoo*arm64*.*
-            out/latest*.yml
+            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.os }}
+          name: out-x64-${{ matrix.platform }}
           path: |
-            out/Zoo*x*64*.*
+            out/*-x64-win.*
+            out/*-x64-mac.*
+            out/*-x86_64-linux.*
+
+      - uses: actions/upload-artifact@v3
+        if: ${{ env.BUILD_RELEASE == 'true' }}
+        with:
+          name: out-yml
+          path: |
+            out/latest*.yml
 
       # TODO: add the 'Build for Mac TestFlight (nightly)' stage back
 
@@ -203,16 +231,20 @@ jobs:
       - uses: actions/upload-artifact@v3
         if: ${{ env.CUT_RELEASE_PR == 'true' }}
         with:
-          name: updater-test-arm64-${{ matrix.os }}
+          name: updater-test-arm64-${{ matrix.platform }}
           path: |
-            out/Zoo*arm64*.*
+            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.os }}
+          name: updater-test-x64-${{ matrix.platform }}
           path: |
-            out/Zoo*x64*.*
+            out/*-x64-win.exe
+            out/*-x64-mac.dmg
+            out/*-x86_64-linux.AppImage
 
 
   publish-apps-release:
@@ -225,7 +257,6 @@ 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) }}
       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' }}
@@ -234,32 +265,37 @@ jobs:
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-arm64-windows-2022
+          name: out-arm64-win
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-x64-windows-2022
+          name: out-x64-win
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-arm64-macos-14
+          name: out-arm64-mac
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-x64-macos-14
+          name: out-x64-mac
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-arm64-ubuntu-22.04
+          name: out-arm64-linux
           path: out
 
       - uses: actions/download-artifact@v3
         with:
-          name: out-x64-ubuntu-22.04
+          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/cargo-test.yml

@@ -62,7 +62,7 @@ jobs:
         shell: bash
         run: |-
           cd "${{ matrix.dir }}"
-          cargo llvm-cov nextest --all --lcov --output-path lcov.info --test-threads=1 --no-fail-fast -P ci 2>&1 | tee /tmp/github-actions.log
+          cargo llvm-cov nextest --workspace --lcov --output-path lcov.info --test-threads=1 --no-fail-fast -P ci 2>&1 | tee /tmp/github-actions.log
         env:
           KITTYCAD_API_TOKEN: ${{secrets.KITTYCAD_API_TOKEN}}
           RUST_MIN_STACK: 10485760000

.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

@@ -2,7 +2,7 @@
 
 ## Zoo Modeling App
 
-live at [app.zoo.dev](https://app.zoo.dev/)
+download at [zoo.dev/modeling-app/download](https://zoo.dev/modeling-app/download)
 
 A CAD application from the future, brought to you by the [Zoo team](https://zoo.dev).
 
@@ -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.
 
@@ -128,7 +128,18 @@ Before you submit a contribution PR to this repo, please ensure that:
 
 ## Release a new version
 
-#### 1. Bump the versions by running `./make-release.sh` and create a Cut Release PR
+#### 1. Bump the versions by running `./make-release.sh`
+
+The `./make-release.sh` script has git commands to pull main but to be sure you can run the following git commands to have a fresh `main` locally.
+
+```
+git branch -D main
+git checkout main
+git pull origin
+./make-release.sh
+# Copy within the back ticks and paste the stdout of the change log
+git push --set-upstream origin <branch name created from ./make-release.sh>
+```
 
 That will create the branch with the updated json files for you:
 - run `./make-release.sh` or `./make-release.sh patch` for a patch update;
@@ -137,28 +148,50 @@ That will create the branch with the updated json files for you:
 
 After it runs you should just need the push the branch and open a PR.
 
-**Important:** It needs to be prefixed with `Cut release v` to build in release mode and a few other things to test in the best context possible, the intent would be for instance to have `Cut release v1.2.3` for the `v1.2.3` release candidate.
+#### 2. Create a Cut Release PR
+
+When you open the PR copy the change log from the output of the `./make-release.sh` script into the description of the PR.
+
+**Important:** Pull request title needs to be prefixed with `Cut release v` to build in release mode and a few other things to test in the best context possible, the intent would be for instance to have `Cut release v1.2.3` for the `v1.2.3` release candidate.
 
 The PR may then serve as a place to discuss the human-readable changelog and extra QA. The `make-release.sh` tool suggests a changelog for you too to be used as PR description, just make sure to delete lines that are not user facing.
 
-#### 2. Smoke test artifacts from the Cut Release PR
+#### 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
 
-We don't have a strict process, but click around and check for anything obvious, posting results as comments in the Cut Release PR.
+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.
 
-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).
+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.
 
-#### 3. Merge the Cut Release PR
+##### 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
 
 This will kick the `create-release` action, that creates a _Draft_ release out of this Cut Release PR merge after less than a minute, with the new version as title and Cut Release PR as description.
 
 
-#### 4. Publish the release
+#### 5. Publish the release
 
 Head over to https://github.com/KittyCAD/modeling-app/releases, the draft release corresponding to the merged Cut Release PR should show up at the top as _Draft_. Click on it, verify the content, and hit _Publish_.
 
-#### 5. Profit
+#### 6. Profit
 
 A new Action kicks in at https://github.com/KittyCAD/modeling-app/actions, which can be found under `release` event filter.
 
@@ -319,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/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 |
 

docs/kcl/types/Path.md

@@ -162,6 +162,28 @@ A base path.
 
 
 ----
+A circular arc, not necessarily tangential to the current point.
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `Arc`|  | No |
+| `center` |`[number, number]`| Center of the circle that this arc is drawn on. | No |
+| `radius` |`number`| Radius of the circle that this arc is drawn on. | No |
+| `from` |`[number, number]`| The from point. | No |
+| `to` |`[number, number]`| The to point. | No |
+| `tag` |[`TagDeclarator`](/docs/kcl/types#tag-declaration)| The tag of the path. | No |
+| `__geoMeta` |[`GeoMeta`](/docs/kcl/types/GeoMeta)| Metadata. | No |
+
+
+----
 
 
 

docs/kcl/types/Sketch.md

@@ -16,8 +16,8 @@ A sketch is a collection of paths.
 
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
-| `id` |`string`| The id of the sketch (this will change when the engine's reference to it changes. | No |
-| `value` |`[` [`Path`](/docs/kcl/types/Path) `]`| The paths in the sketch. | No |
+| `id` |`string`| The id of the sketch (this will change when the engine's reference to it changes). | No |
+| `paths` |`[` [`Path`](/docs/kcl/types/Path) `]`| The paths in the sketch. | No |
 | `on` |[`SketchSurface`](/docs/kcl/types/SketchSurface)| What the sketch is on (can be a plane or a face). | No |
 | `start` |[`BasePath`](/docs/kcl/types/BasePath)| The starting path. | No |
 | `tags` |`object`| Tag identifiers that have been declared in this sketch. | No |

docs/kcl/types/SketchSet.md

@@ -25,8 +25,8 @@ A sketch is a collection of paths.
 | Property | Type | Description | Required |
 |----------|------|-------------|----------|
 | `type` |enum: `sketch`|  | No |
-| `id` |`string`| The id of the sketch (this will change when the engine's reference to it changes. | No |
-| `value` |`[` [`Path`](/docs/kcl/types/Path) `]`| The paths in the sketch. | No |
+| `id` |`string`| The id of the sketch (this will change when the engine's reference to it changes). | No |
+| `paths` |`[` [`Path`](/docs/kcl/types/Path) `]`| The paths in the sketch. | No |
 | `on` |[`SketchSurface`](/docs/kcl/types/SketchSurface)| What the sketch is on (can be a plane or a face). | No |
 | `start` |[`BasePath`](/docs/kcl/types/BasePath)| The starting path. | No |
 | `tags` |`object`| Tag identifiers that have been declared in this sketch. | No |

docs/kcl/types/TagEngineInfo.md

@@ -18,7 +18,7 @@ Engine information for a tag.
 |----------|------|-------------|----------|
 | `id` |`string`| The id of the tagged object. | No |
 | `sketch` |`string`| The sketch the tag is on. | No |
-| `path` |[`BasePath`](/docs/kcl/types/BasePath)| The path the tag is on. | No |
+| `path` |[`Path`](/docs/kcl/types/Path)| The path the tag is on. | No |
 | `surface` |[`ExtrudeSurface`](/docs/kcl/types/ExtrudeSurface)| The surface information for the tag. | No |
 
 

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

@@ -313,3 +313,45 @@ test(
     await electronApp.close()
   }
 )
+
+test(
+  'external change of file contents are reflected in editor',
+  { tag: '@electron' },
+  async ({ browserName }, testInfo) => {
+    const PROJECT_DIR_NAME = 'lee-was-here'
+    const {
+      electronApp,
+      page,
+      dir: projectsDir,
+    } = await setupElectron({
+      testInfo,
+      folderSetupFn: async (dir) => {
+        const aProjectDir = join(dir, PROJECT_DIR_NAME)
+        await fsp.mkdir(aProjectDir, { recursive: true })
+      },
+    })
+
+    const u = await getUtils(page)
+    await page.setViewportSize({ width: 1200, height: 500 })
+
+    await test.step('Open the project', async () => {
+      await expect(page.getByText(PROJECT_DIR_NAME)).toBeVisible()
+      await page.getByText(PROJECT_DIR_NAME).click()
+      await u.waitForPageLoad()
+    })
+
+    await u.openFilePanel()
+    await u.openKclCodePanel()
+
+    await test.step('Write to file externally and check for changed content', async () => {
+      const content = 'ha he ho ho ha blap scap be dap'
+      await fsp.writeFile(
+        join(projectsDir, PROJECT_DIR_NAME, 'main.kcl'),
+        content
+      )
+      await u.editorTextMatches(content)
+    })
+
+    await electronApp.close()
+  }
+)

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/desktop-export.spec.ts

@@ -104,7 +104,7 @@ test(
             },
             { timeout: 15_000 }
           )
-          .toBe(431341)
+          .toBeGreaterThan(300_000)
 
         // clean up output.gltf
         await fsp.rm('output.gltf')
@@ -179,7 +179,7 @@ test(
             },
             { timeout: 15_000 }
           )
-          .toBe(102040)
+          .toBeGreaterThan(100_000)
 
         // clean up output.gltf
         await fsp.rm('output.gltf')

e2e/playwright/editor-tests.spec.ts

@@ -1,6 +1,16 @@
 import { test, expect } from '@playwright/test'
+import fsp from 'fs/promises'
 import { uuidv4 } from 'lib/utils'
-import { getUtils, setup, tearDown } from './test-utils'
+import {
+  darkModeBgColor,
+  darkModePlaneColorXZ,
+  executorInputPath,
+  getUtils,
+  setup,
+  setupElectron,
+  tearDown,
+} from './test-utils'
+import { join } from 'path'
 
 test.beforeEach(async ({ context, page }, testInfo) => {
   await setup(context, page, testInfo)
@@ -974,4 +984,84 @@ test.describe('Editor tests', () => {
     |> close(%)
     |> extrude(5, %)`)
   })
+
+  test(
+    `Can use the import stdlib function on a local OBJ file`,
+    { tag: '@electron' },
+    async ({ browserName }, testInfo) => {
+      const { electronApp, page } = await setupElectron({
+        testInfo,
+        folderSetupFn: async (dir) => {
+          const bracketDir = join(dir, 'cube')
+          await fsp.mkdir(bracketDir, { recursive: true })
+          await fsp.copyFile(
+            executorInputPath('cube.obj'),
+            join(bracketDir, 'cube.obj')
+          )
+          await fsp.writeFile(join(bracketDir, 'main.kcl'), '')
+        },
+      })
+      const viewportSize = { width: 1200, height: 500 }
+      await page.setViewportSize(viewportSize)
+
+      // Locators and constants
+      const u = await getUtils(page)
+      const projectLink = page.getByRole('link', { name: 'cube' })
+      const gizmo = page.locator('[aria-label*=gizmo]')
+      const resetCameraButton = page.getByRole('button', { name: 'Reset view' })
+      const locationToHavColor = async (
+        position: { x: number; y: number },
+        color: [number, number, number]
+      ) => {
+        return u.getGreatestPixDiff(position, color)
+      }
+      const notTheOrigin = {
+        x: viewportSize.width * 0.55,
+        y: viewportSize.height * 0.3,
+      }
+      const origin = { x: viewportSize.width / 2, y: viewportSize.height / 2 }
+      const errorIndicators = page.locator('.cm-lint-marker-error')
+
+      await test.step(`Open the empty file, see the default planes`, async () => {
+        await projectLink.click()
+        await u.waitForPageLoad()
+        await expect
+          .poll(
+            async () => locationToHavColor(notTheOrigin, darkModePlaneColorXZ),
+            {
+              timeout: 5000,
+              message: 'XZ plane color is visible',
+            }
+          )
+          .toBeLessThan(15)
+      })
+      await test.step(`Write the import function line`, async () => {
+        await u.codeLocator.fill(`import('cube.obj')`)
+        await page.waitForTimeout(800)
+      })
+      await test.step(`Reset the camera before checking`, async () => {
+        await u.doAndWaitForCmd(async () => {
+          await gizmo.click({ button: 'right' })
+          await resetCameraButton.click()
+        }, 'zoom_to_fit')
+      })
+      await test.step(`Verify that we see the imported geometry and no errors`, async () => {
+        await expect(errorIndicators).toHaveCount(0)
+        await expect
+          .poll(async () => locationToHavColor(origin, darkModePlaneColorXZ), {
+            timeout: 3000,
+            message: 'Plane color should not be visible',
+          })
+          .toBeGreaterThan(15)
+        await expect
+          .poll(async () => locationToHavColor(origin, darkModeBgColor), {
+            timeout: 3000,
+            message: 'Background color should not be visible',
+          })
+          .toBeGreaterThan(15)
+      })
+
+      await electronApp.close()
+    }
+  )
 })

e2e/playwright/file-tree.spec.ts

@@ -136,6 +136,9 @@ test.describe('when using the file tree to', () => {
       )
       await pasteCodeInEditor(kclCube)
 
+      // TODO: We have a timeout of 1s between edits to write to disk. If you reload the page too quickly it won't write to disk.
+      await tronApp.page.waitForTimeout(2000)
+
       await renameFile(fromFile, toFile)
       await tronApp.page.reload()
 
@@ -222,9 +225,11 @@ test.describe('when using the file tree to', () => {
       )
       await pasteCodeInEditor(kclCube)
 
+      // TODO: We have a timeout of 1s between edits to write to disk. If you reload the page too quickly it won't write to disk.
+      await tronApp.page.waitForTimeout(2000)
+
       const kcl1 = 'main.kcl'
       const kcl2 = '2.kcl'
-
       await createNewFileAndSelect(kcl2)
       const kclCylinder = await fsp.readFile(
         'src/wasm-lib/tests/executor/inputs/cylinder.kcl',
@@ -232,6 +237,9 @@ test.describe('when using the file tree to', () => {
       )
       await pasteCodeInEditor(kclCylinder)
 
+      // TODO: We have a timeout of 1s between edits to write to disk. If you reload the page too quickly it won't write to disk.
+      await tronApp.page.waitForTimeout(2000)
+
       await renameFile(kcl2, kcl1)
 
       await test.step(`Postcondition: ${kcl1} still has the original content`, async () => {
@@ -960,4 +968,171 @@ _test.describe('Deleting items from the file pane', () => {
     'TODO - delete folder we are in, with no main.kcl',
     async () => {}
   )
+
+  // Copied from tests above.
+  _test(
+    `external deletion of project navigates back home`,
+    { tag: '@electron' },
+    async ({ browserName }, testInfo) => {
+      const TEST_PROJECT_NAME = 'Test Project'
+      const {
+        electronApp,
+        page,
+        dir: projectsDirName,
+      } = await setupElectron({
+        testInfo,
+        folderSetupFn: async (dir) => {
+          await fsp.mkdir(join(dir, TEST_PROJECT_NAME), { recursive: true })
+          await fsp.mkdir(join(dir, TEST_PROJECT_NAME, 'folderToDelete'), {
+            recursive: true,
+          })
+          await fsp.copyFile(
+            executorInputPath('basic_fillet_cube_end.kcl'),
+            join(dir, TEST_PROJECT_NAME, 'main.kcl')
+          )
+          await fsp.copyFile(
+            executorInputPath('cylinder.kcl'),
+            join(dir, TEST_PROJECT_NAME, 'folderToDelete', 'someFileWithin.kcl')
+          )
+        },
+      })
+      const u = await getUtils(page)
+      await page.setViewportSize({ width: 1200, height: 500 })
+
+      // Constants and locators
+      const projectCard = page.getByText(TEST_PROJECT_NAME)
+      const projectMenuButton = page.getByTestId('project-sidebar-toggle')
+      const folderToDelete = page.getByRole('button', {
+        name: 'folderToDelete',
+      })
+      const fileWithinFolder = page.getByRole('listitem').filter({
+        has: page.getByRole('button', { name: 'someFileWithin.kcl' }),
+      })
+
+      await _test.step(
+        'Open project and navigate into folderToDelete',
+        async () => {
+          await projectCard.click()
+          await u.waitForPageLoad()
+          await _expect(projectMenuButton).toContainText('main.kcl')
+          await u.closeKclCodePanel()
+          await u.openFilePanel()
+
+          await folderToDelete.click()
+          await _expect(fileWithinFolder).toBeVisible()
+          await fileWithinFolder.click()
+          await _expect(projectMenuButton).toContainText('someFileWithin.kcl')
+        }
+      )
+
+      // Point of divergence. Delete the project folder and see if it goes back
+      // to the home view.
+      await _test.step(
+        'Delete projectsDirName/<project-name> externally',
+        async () => {
+          await fsp.rm(join(projectsDirName, TEST_PROJECT_NAME), {
+            recursive: true,
+            force: true,
+          })
+        }
+      )
+
+      await _test.step('Check the app is back on the home view', async () => {
+        const projectsDirLink = page.getByText('Loaded from')
+        await _expect(projectsDirLink).toBeVisible()
+      })
+
+      await electronApp.close()
+    }
+  )
+
+  // Similar to the above
+  _test(
+    `external deletion of file in sub-directory updates the file tree and recreates it on code editor typing`,
+    { tag: '@electron' },
+    async ({ browserName }, testInfo) => {
+      const TEST_PROJECT_NAME = 'Test Project'
+      const {
+        electronApp,
+        page,
+        dir: projectsDirName,
+      } = await setupElectron({
+        testInfo,
+        folderSetupFn: async (dir) => {
+          await fsp.mkdir(join(dir, TEST_PROJECT_NAME), { recursive: true })
+          await fsp.mkdir(join(dir, TEST_PROJECT_NAME, 'folderToDelete'), {
+            recursive: true,
+          })
+          await fsp.copyFile(
+            executorInputPath('basic_fillet_cube_end.kcl'),
+            join(dir, TEST_PROJECT_NAME, 'main.kcl')
+          )
+          await fsp.copyFile(
+            executorInputPath('cylinder.kcl'),
+            join(dir, TEST_PROJECT_NAME, 'folderToDelete', 'someFileWithin.kcl')
+          )
+        },
+      })
+      const u = await getUtils(page)
+      await page.setViewportSize({ width: 1200, height: 500 })
+
+      // Constants and locators
+      const projectCard = page.getByText(TEST_PROJECT_NAME)
+      const projectMenuButton = page.getByTestId('project-sidebar-toggle')
+      const folderToDelete = page.getByRole('button', {
+        name: 'folderToDelete',
+      })
+      const fileWithinFolder = page.getByRole('listitem').filter({
+        has: page.getByRole('button', { name: 'someFileWithin.kcl' }),
+      })
+
+      await _test.step(
+        'Open project and navigate into folderToDelete',
+        async () => {
+          await projectCard.click()
+          await u.waitForPageLoad()
+          await _expect(projectMenuButton).toContainText('main.kcl')
+
+          await u.openFilePanel()
+
+          await folderToDelete.click()
+          await _expect(fileWithinFolder).toBeVisible()
+          await fileWithinFolder.click()
+          await _expect(projectMenuButton).toContainText('someFileWithin.kcl')
+        }
+      )
+
+      await _test.step(
+        'Delete projectsDirName/<project-name> externally',
+        async () => {
+          await fsp.rm(
+            join(
+              projectsDirName,
+              TEST_PROJECT_NAME,
+              'folderToDelete',
+              'someFileWithin.kcl'
+            )
+          )
+        }
+      )
+
+      await _test.step('Check the file is gone in the file tree', async () => {
+        await _expect(
+          page.getByTestId('file-pane-scroll-container')
+        ).not.toContainText('someFileWithin.kcl')
+      })
+
+      await _test.step(
+        'Check the file is back in the file tree after typing in code editor',
+        async () => {
+          await u.pasteCodeInEditor('hello = 1')
+          await _expect(
+            page.getByTestId('file-pane-scroll-container')
+          ).toContainText('someFileWithin.kcl')
+        }
+      )
+
+      await electronApp.close()
+    }
+  )
 })

e2e/playwright/fixtures/sceneFixture.ts

@@ -13,6 +13,13 @@ type mouseParams = {
   pixelDiff: number
 }
 
+type SceneSerialised = {
+  camera: {
+    position: [number, number, number]
+    target: [number, number, number]
+  }
+}
+
 export class SceneFixture {
   public page: Page
 
@@ -22,6 +29,22 @@ export class SceneFixture {
     this.page = page
     this.reConstruct(page)
   }
+  private _serialiseScene = async (): Promise<SceneSerialised> => {
+    const camera = await this.getCameraInfo()
+
+    return {
+      camera,
+    }
+  }
+
+  expectState = async (expected: SceneSerialised) => {
+    return expect
+      .poll(() => this._serialiseScene(), {
+        message: `Expected scene state to match`,
+      })
+      .toEqual(expected)
+  }
+
   reConstruct = (page: Page) => {
     this.page = page
 
@@ -31,7 +54,7 @@ export class SceneFixture {
   makeMouseHelpers = (
     x: number,
     y: number,
-    { steps }: { steps: number } = { steps: 5000 }
+    { steps }: { steps: number } = { steps: 20 }
   ) =>
     [
       (clickParams?: mouseParams) => {
@@ -87,6 +110,36 @@ export class SceneFixture {
     )
     await closeDebugPanel(this.page)
   }
+  /** Forces a refresh of the camera position and target displayed
+   *  in the debug panel and then returns the values of the fields
+   */
+  async getCameraInfo() {
+    await openAndClearDebugPanel(this.page)
+    await sendCustomCmd(this.page, {
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'default_camera_get_settings',
+      },
+    })
+    await this.waitForExecutionDone()
+    const position = await Promise.all([
+      this.page.getByTestId('cam-x-position').inputValue().then(Number),
+      this.page.getByTestId('cam-y-position').inputValue().then(Number),
+      this.page.getByTestId('cam-z-position').inputValue().then(Number),
+    ])
+    const target = await Promise.all([
+      this.page.getByTestId('cam-x-target').inputValue().then(Number),
+      this.page.getByTestId('cam-y-target').inputValue().then(Number),
+      this.page.getByTestId('cam-z-target').inputValue().then(Number),
+    ])
+    await closeDebugPanel(this.page)
+    return {
+      position,
+      target,
+    }
+  }
+
   waitForExecutionDone = async () => {
     await expect(this.exeIndicator).toBeVisible()
   }
@@ -114,4 +167,17 @@ export class SceneFixture {
         )
       })
   }
+
+  get gizmo() {
+    return this.page.locator('[aria-label*=gizmo]')
+  }
+
+  async clickGizmoMenuItem(name: string) {
+    await this.gizmo.click({ button: 'right' })
+    const buttonToTest = this.page.getByRole('button', {
+      name: name,
+    })
+    await expect(buttonToTest).toBeVisible()
+    await buttonToTest.click()
+  }
 }

e2e/playwright/onboarding-tests.spec.ts

@@ -55,6 +55,53 @@ test.describe('Onboarding tests', () => {
     await expect(page.locator('.cm-content')).toContainText('// Shelf Bracket')
   })
 
+  test(
+    'Desktop: fresh onboarding executes and loads',
+    { tag: '@electron' },
+    async ({ browserName: _ }, testInfo) => {
+      const { electronApp, page } = await setupElectron({
+        testInfo,
+        appSettings: {
+          app: {
+            onboardingStatus: 'incomplete',
+          },
+        },
+        cleanProjectDir: true,
+      })
+
+      const u = await getUtils(page)
+
+      const viewportSize = { width: 1200, height: 500 }
+      await page.setViewportSize(viewportSize)
+
+      // Locators and constants
+      const newProjectButton = page.getByRole('button', { name: 'New project' })
+      const projectLink = page.getByTestId('project-link')
+
+      await test.step(`Create a project and open to the onboarding`, async () => {
+        await newProjectButton.click()
+        await projectLink.click()
+        await test.step(`Ensure the engine connection works by testing the sketch button`, async () => {
+          await u.waitForPageLoad()
+        })
+      })
+
+      await test.step(`Ensure we see the onboarding stuff`, async () => {
+        // Test that the onboarding pane loaded
+        await expect(
+          page.getByText('Welcome to Modeling App! This')
+        ).toBeVisible()
+
+        // *and* that the code is shown in the editor
+        await expect(page.locator('.cm-content')).toContainText(
+          '// Shelf Bracket'
+        )
+      })
+
+      await electronApp.close()
+    }
+  )
+
   test('Code resets after confirmation', async ({ page }) => {
     const initialCode = `sketch001 = startSketchOn('XZ')`
 

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,
@@ -255,7 +255,7 @@ test.describe('Can export from electron app', () => {
               },
               { timeout: 15_000 }
             )
-            .toBe(431341)
+            .toBeGreaterThan(300_000)
 
           // clean up output.gltf
           await fsp.rm('output.gltf')
@@ -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',
@@ -852,7 +851,7 @@ test(
   }
 )
 
-test(
+test.fixme(
   'When the project folder is empty, user can create new project and open it.',
   { tag: '@electron' },
   async ({ browserName }, testInfo) => {
@@ -862,6 +861,12 @@ test(
 
     page.on('console', console.log)
 
+    // Locators and constants
+    const gizmo = page.locator('[aria-label*=gizmo]')
+    const resetCameraButton = page.getByRole('button', { name: 'Reset view' })
+    const pointOnModel = { x: 660, y: 250 }
+    const expectedStartCamZPosition = 15633.47
+
     // expect to see text "No Projects found"
     await expect(page.getByText('No Projects found')).toBeVisible()
 
@@ -874,16 +879,7 @@ test(
 
     await page.getByText('project-000').click()
 
-    await expect(page.getByTestId('loading')).toBeAttached()
-    await expect(page.getByTestId('loading')).not.toBeAttached({
-      timeout: 20_000,
-    })
-
-    await expect(
-      page.getByRole('button', { name: 'Start Sketch' })
-    ).toBeEnabled({
-      timeout: 20_000,
-    })
+    await u.waitForPageLoad()
 
     await page.locator('.cm-content').fill(`sketch001 = startSketchOn('XZ')
   |> startProfileAt([-87.4, 282.92], %)
@@ -893,8 +889,28 @@ test(
   |> lineTo([profileStartX(%), profileStartY(%)], %)
   |> close(%)
 extrude001 = extrude(200, sketch001)`)
+    await page.waitForTimeout(800)
 
-    const pointOnModel = { x: 660, y: 250 }
+    async function getCameraZValue() {
+      return page
+        .getByTestId('cam-z-position')
+        .inputValue()
+        .then((value) => parseFloat(value))
+    }
+
+    await test.step(`Reset camera`, async () => {
+      await u.openDebugPanel()
+      await u.clearCommandLogs()
+      await u.doAndWaitForCmd(async () => {
+        await gizmo.click({ button: 'right' })
+        await resetCameraButton.click()
+      }, 'zoom_to_fit')
+      await expect
+        .poll(getCameraZValue, {
+          message: 'Camera Z should be at expected position after reset',
+        })
+        .toEqual(expectedStartCamZPosition)
+    })
 
     // gray at this pixel means the stream has loaded in the most
     // user way we can verify it (pixel color)
@@ -902,7 +918,7 @@ extrude001 = extrude(200, sketch001)`)
       .poll(() => u.getGreatestPixDiff(pointOnModel, [143, 143, 143]), {
         timeout: 10_000,
       })
-      .toBeLessThan(15)
+      .toBeLessThan(30)
 
     await expect(async () => {
       await page.mouse.move(0, 0, { steps: 5 })

e2e/playwright/snapshot-tests.spec.ts

@@ -471,7 +471,7 @@ test(
 
     await page.mouse.move(startXPx + PUR * 30, 500 - PUR * 20, { steps: 10 })
 
-    await page.waitForTimeout(300)
+    await page.waitForTimeout(1000)
 
     await expect(page).toHaveScreenshot({
       maxDiffPixels: 100,
@@ -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()
@@ -529,6 +528,7 @@ test(
     // Draw the rectangle
     await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 30)
     await page.mouse.move(startXPx + PUR * 10, 500 - PUR * 10, { steps: 5 })
+    await page.waitForTimeout(800)
 
     // Ensure the draft rectangle looks the same as it usually does
     await expect(page).toHaveScreenshot({
@@ -670,6 +670,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 +688,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')],
       })
     })
 
@@ -894,7 +896,7 @@ test(
     // Wait for the second extrusion to appear
     // TODO: Find a way to truly know that the objects have finished
     // rendering, because an execution-done message is not sufficient.
-    await page.waitForTimeout(1000)
+    await page.waitForTimeout(2000)
 
     await expect(page).toHaveScreenshot({
       maxDiffPixels: 100,
@@ -938,7 +940,7 @@ test(
     // Wait for the second extrusion to appear
     // TODO: Find a way to truly know that the objects have finished
     // rendering, because an execution-done message is not sufficient.
-    await page.waitForTimeout(1000)
+    await page.waitForTimeout(2000)
 
     await expect(page).toHaveScreenshot({
       maxDiffPixels: 100,

e2e/playwright/test-utils.ts

@@ -47,6 +47,14 @@ export const commonPoints = {
   num2: 14.44,
 }
 
+/** A semi-reliable color to check the default XZ plane on
+ * in dark mode in the default camera position
+ */
+export const darkModePlaneColorXZ: [number, number, number] = [50, 50, 99]
+
+/** A semi-reliable color to check the default dark mode bg color against */
+export const darkModeBgColor: [number, number, number] = [27, 27, 27]
+
 export const editorSelector = '[role="textbox"][data-language="kcl"]'
 type PaneId = 'variables' | 'code' | 'files' | 'logs'
 
@@ -463,6 +471,9 @@ export async function getUtils(page: Page, test_?: typeof test) {
       return test_?.step(
         `Create and select project with text "${hasText}"`,
         async () => {
+          // Without this, we get unreliable project creation. It's probably
+          // due to a race between the FS being read and clicking doing something.
+          await page.waitForTimeout(100)
           await page.getByTestId('home-new-file').click()
           const projectLinksPost = page.getByTestId('project-link')
           await projectLinksPost.filter({ hasText }).click()
@@ -492,6 +503,11 @@ export async function getUtils(page: Page, test_?: typeof test) {
 
     createNewFile: async (name: string) => {
       return test?.step(`Create a file named ${name}`, async () => {
+        // If the application is in the middle of connecting a stream
+        // then creating a new file won't work in the end.
+        await expect(
+          page.getByRole('button', { name: 'Start Sketch' })
+        ).not.toBeDisabled()
         await page.getByTestId('create-file-button').click()
         await page.getByTestId('file-rename-field').fill(name)
         await page.keyboard.press('Enter')
@@ -872,10 +888,20 @@ export async function setupElectron({
     const tempSettingsFilePath = join(projectDirName, SETTINGS_FILE_NAME)
     const settingsOverrides = TOML.stringify(
       appSettings
-        ? { settings: appSettings }
-        : {
-            ...TEST_SETTINGS,
+        ? {
             settings: {
+              ...TEST_SETTINGS,
+              ...appSettings,
+              app: {
+                ...TEST_SETTINGS.app,
+                projectDirectory: projectDirName,
+                ...appSettings.app,
+              },
+            },
+          }
+        : {
+            settings: {
+              ...TEST_SETTINGS,
               app: {
                 ...TEST_SETTINGS.app,
                 projectDirectory: projectDirName,

e2e/playwright/testing-gizmo.spec.ts

@@ -1,18 +1,18 @@
-import { test, expect } from '@playwright/test'
-
+import { _test, _expect } from './playwright-deprecated'
+import { test } from './fixtures/fixtureSetup'
 import { getUtils, setup, tearDown } from './test-utils'
 import { uuidv4 } from 'lib/utils'
 import { TEST_CODE_GIZMO } from './storageStates'
 
-test.beforeEach(async ({ context, page }, testInfo) => {
+_test.beforeEach(async ({ context, page }, testInfo) => {
   await setup(context, page, testInfo)
 })
 
-test.afterEach(async ({ page }, testInfo) => {
+_test.afterEach(async ({ page }, testInfo) => {
   await tearDown(page, testInfo)
 })
 
-test.describe('Testing Gizmo', () => {
+_test.describe('Testing Gizmo', () => {
   const cases = [
     {
       testDescription: 'top view',
@@ -57,7 +57,7 @@ test.describe('Testing Gizmo', () => {
     expectedCameraTarget,
     testDescription,
   } of cases) {
-    test(`check ${testDescription}`, async ({ page, browserName }) => {
+    _test(`check ${testDescription}`, async ({ page, browserName }) => {
       const u = await getUtils(page)
       await page.addInitScript((TEST_CODE_GIZMO) => {
         localStorage.setItem('persistCode', TEST_CODE_GIZMO)
@@ -117,30 +117,30 @@ test.describe('Testing Gizmo', () => {
 
       await Promise.all([
         // position
-        expect(page.getByTestId('cam-x-position')).toHaveValue(
+        _expect(page.getByTestId('cam-x-position')).toHaveValue(
           expectedCameraPosition.x.toString()
         ),
-        expect(page.getByTestId('cam-y-position')).toHaveValue(
+        _expect(page.getByTestId('cam-y-position')).toHaveValue(
           expectedCameraPosition.y.toString()
         ),
-        expect(page.getByTestId('cam-z-position')).toHaveValue(
+        _expect(page.getByTestId('cam-z-position')).toHaveValue(
           expectedCameraPosition.z.toString()
         ),
         // target
-        expect(page.getByTestId('cam-x-target')).toHaveValue(
+        _expect(page.getByTestId('cam-x-target')).toHaveValue(
           expectedCameraTarget.x.toString()
         ),
-        expect(page.getByTestId('cam-y-target')).toHaveValue(
+        _expect(page.getByTestId('cam-y-target')).toHaveValue(
           expectedCameraTarget.y.toString()
         ),
-        expect(page.getByTestId('cam-z-target')).toHaveValue(
+        _expect(page.getByTestId('cam-z-target')).toHaveValue(
           expectedCameraTarget.z.toString()
         ),
       ])
     })
   }
 
-  test('Context menu and popover menu', async ({ page }) => {
+  _test('Context menu and popover menu', async ({ page }) => {
     const testCase = {
       testDescription: 'Right view',
       expectedCameraPosition: { x: 5660.02, y: -152, z: 26 },
@@ -196,7 +196,7 @@ test.describe('Testing Gizmo', () => {
     const buttonToTest = page.getByRole('button', {
       name: testCase.testDescription,
     })
-    await expect(buttonToTest).toBeVisible()
+    await _expect(buttonToTest).toBeVisible()
     await buttonToTest.click()
 
     // Now assert we've moved to the correct view
@@ -215,23 +215,23 @@ test.describe('Testing Gizmo', () => {
 
     await Promise.all([
       // position
-      expect(page.getByTestId('cam-x-position')).toHaveValue(
+      _expect(page.getByTestId('cam-x-position')).toHaveValue(
         testCase.expectedCameraPosition.x.toString()
       ),
-      expect(page.getByTestId('cam-y-position')).toHaveValue(
+      _expect(page.getByTestId('cam-y-position')).toHaveValue(
         testCase.expectedCameraPosition.y.toString()
       ),
-      expect(page.getByTestId('cam-z-position')).toHaveValue(
+      _expect(page.getByTestId('cam-z-position')).toHaveValue(
         testCase.expectedCameraPosition.z.toString()
       ),
       // target
-      expect(page.getByTestId('cam-x-target')).toHaveValue(
+      _expect(page.getByTestId('cam-x-target')).toHaveValue(
         testCase.expectedCameraTarget.x.toString()
       ),
-      expect(page.getByTestId('cam-y-target')).toHaveValue(
+      _expect(page.getByTestId('cam-y-target')).toHaveValue(
         testCase.expectedCameraTarget.y.toString()
       ),
-      expect(page.getByTestId('cam-z-target')).toHaveValue(
+      _expect(page.getByTestId('cam-z-target')).toHaveValue(
         testCase.expectedCameraTarget.z.toString()
       ),
     ])
@@ -242,8 +242,60 @@ test.describe('Testing Gizmo', () => {
     const gizmoPopoverButton = page.getByRole('button', {
       name: 'view settings',
     })
-    await expect(gizmoPopoverButton).toBeVisible()
+    await _expect(gizmoPopoverButton).toBeVisible()
     await gizmoPopoverButton.click()
-    await expect(buttonToTest).toBeVisible()
+    await _expect(buttonToTest).toBeVisible()
+  })
+})
+
+test.describe(`Testing gizmo, fixture-based`, () => {
+  test('Center on selection from menu', async ({
+    app,
+    cmdBar,
+    editor,
+    toolbar,
+    scene,
+  }) => {
+    test.skip(
+      process.platform === 'win32',
+      'Fails on windows in CI, can not be replicated locally on windows.'
+    )
+
+    await test.step(`Setup`, async () => {
+      const file = await app.getInputFile('test-circle-extrude.kcl')
+      await app.initialise(file)
+      await scene.expectState({
+        camera: {
+          position: [4982.21, -23865.37, 13810.64],
+          target: [4982.21, 0, 2737.1],
+        },
+      })
+    })
+    const [clickCircle, moveToCircle] = scene.makeMouseHelpers(582, 217)
+
+    await test.step(`Select an edge of this circle`, async () => {
+      const circleSnippet =
+        'circle({ center: [318.33, 168.1], radius: 182.8 }, %)'
+      await moveToCircle()
+      await clickCircle()
+      await editor.expectState({
+        activeLines: [circleSnippet.slice(-5)],
+        highlightedCode: circleSnippet,
+        diagnostics: [],
+      })
+    })
+
+    await test.step(`Center on selection from menu`, async () => {
+      await scene.clickGizmoMenuItem('Center view on selection')
+    })
+
+    await test.step(`Verify the camera moved`, async () => {
+      await scene.expectState({
+        camera: {
+          position: [0, -23865.37, 11073.53],
+          target: [0, 0, 0],
+        },
+      })
+    })
   })
 })

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

e2e/playwright/testing-settings.spec.ts

@@ -9,6 +9,7 @@ import {
   executorInputPath,
 } from './test-utils'
 import { SaveSettingsPayload, SettingsLevel } from 'lib/settings/settingsTypes'
+import { SETTINGS_FILE_NAME, PROJECT_SETTINGS_FILE_NAME } from 'lib/constants'
 import {
   TEST_SETTINGS_KEY,
   TEST_SETTINGS_CORRUPTED,
@@ -343,7 +344,7 @@ test.describe('Testing settings', () => {
 
       // Selectors and constants
       const errorHeading = page.getByRole('heading', {
-        name: 'An unextected error occurred',
+        name: 'An unexpected error occurred',
       })
       const projectDirLink = page.getByText('Loaded from')
 
@@ -372,7 +373,7 @@ test.describe('Testing settings', () => {
 
       // Selectors and constants
       const errorHeading = page.getByRole('heading', {
-        name: 'An unextected error occurred',
+        name: 'An unexpected error occurred',
       })
       const projectDirLink = page.getByText('Loaded from')
 
@@ -384,6 +385,117 @@ test.describe('Testing settings', () => {
     }
   )
 
+  // It was much easier to test the logo color than the background stream color.
+  test(
+    'user settings reload on external change, on project and modeling view',
+    { tag: '@electron' },
+    async ({ browserName }, testInfo) => {
+      const {
+        electronApp,
+        page,
+        dir: projectDirName,
+      } = await setupElectron({
+        testInfo,
+        appSettings: {
+          app: {
+            // Doesn't matter what you set it to. It will
+            // default to 264.5
+            themeColor: '0',
+          },
+        },
+      })
+
+      await page.setViewportSize({ width: 1200, height: 500 })
+
+      const logoLink = page.getByTestId('app-logo')
+      const projectDirLink = page.getByText('Loaded from')
+
+      await test.step('Wait for project view', async () => {
+        await expect(projectDirLink).toBeVisible()
+        await expect(logoLink).toHaveCSS('--primary-hue', '264.5')
+      })
+
+      const changeColor = async (color: string) => {
+        const tempSettingsFilePath = join(projectDirName, SETTINGS_FILE_NAME)
+        let tomlStr = await fsp.readFile(tempSettingsFilePath, 'utf-8')
+        tomlStr = tomlStr.replace(/(themeColor = ")[0-9]+(")/, `$1${color}$2`)
+        await fsp.writeFile(tempSettingsFilePath, tomlStr)
+      }
+
+      await test.step('Check color of logo changed', async () => {
+        await changeColor('99')
+        await expect(logoLink).toHaveCSS('--primary-hue', '99')
+      })
+
+      await test.step('Check color of logo changed when in modeling view', async () => {
+        await page.getByRole('button', { name: 'New project' }).click()
+        await page.getByTestId('project-link').first().click()
+        await changeColor('58')
+        await expect(logoLink).toHaveCSS('--primary-hue', '58')
+      })
+
+      await test.step('Check going back to projects view still changes the color', async () => {
+        await logoLink.click()
+        await expect(projectDirLink).toBeVisible()
+        await changeColor('21')
+        await expect(logoLink).toHaveCSS('--primary-hue', '21')
+      })
+      await electronApp.close()
+    }
+  )
+
+  test(
+    'project settings reload on external change',
+    { tag: '@electron' },
+    async ({ browserName }, testInfo) => {
+      const {
+        electronApp,
+        page,
+        dir: projectDirName,
+      } = await setupElectron({
+        testInfo,
+      })
+
+      await page.setViewportSize({ width: 1200, height: 500 })
+
+      const logoLink = page.getByTestId('app-logo')
+      const projectDirLink = page.getByText('Loaded from')
+
+      await test.step('Wait for project view', async () => {
+        await expect(projectDirLink).toBeVisible()
+      })
+
+      const projectLinks = page.getByTestId('project-link')
+      const oldCount = await projectLinks.count()
+      await page.getByRole('button', { name: 'New project' }).click()
+      await expect(projectLinks).toHaveCount(oldCount + 1)
+      await projectLinks.filter({ hasText: 'project-000' }).first().click()
+
+      const changeColorFs = async (color: string) => {
+        const tempSettingsFilePath = join(
+          projectDirName,
+          'project-000',
+          PROJECT_SETTINGS_FILE_NAME
+        )
+        await fsp.writeFile(
+          tempSettingsFilePath,
+          `[settings.app]\nthemeColor = "${color}"`
+        )
+      }
+
+      await test.step('Check the color is first starting as we expect', async () => {
+        await expect(logoLink).toHaveCSS('--primary-hue', '264.5')
+      })
+
+      await test.step('Check color of logo changed', async () => {
+        await changeColorFs('99')
+        await expect(logoLink).toHaveCSS('--primary-hue', '99')
+      })
+
+      await electronApp.close()
+    }
+  )
+
   test(
     `Closing settings modal should go back to the original file being viewed`,
     { tag: '@electron' },

electron-builder.yml

@@ -32,10 +32,10 @@ win:
       arch:
         - x64
         - arm64
-    - target: msi
-      arch:
-        - x64
-        - arm64
+    # - target: msi
+    #   arch:
+    #     - x64
+    #     - arm64
   signingHashAlgorithms:
     - sha256
   sign: "./sign-win.js"
@@ -47,9 +47,9 @@ win:
       mimeType: text/vnd.zoo.kcl
       description: Zoo KCL File
       role: Editor
-msi:
-  oneClick: false
-  perMachine: true
+# msi:
+#   oneClick: false
+#   perMachine: true
 nsis:
   oneClick: false
   perMachine: true
@@ -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

@@ -2,7 +2,7 @@ import fs from 'node:fs/promises'
 import fsSync from 'node:fs'
 import path from 'path'
 import { dialog, shell } from 'electron'
-import { MachinesListing } from 'lib/machineManager'
+import { MachinesListing } from 'components/MachineManagerProvider'
 
 type EnvFn = (value?: string) => string
 
@@ -20,11 +20,11 @@ export interface IElectronAPI {
   version: typeof process.env.version
   watchFileOn: (
     path: string,
+    key: string,
     callback: (eventType: string, path: string) => void
   ) => void
-  watchFileOff: (path: string) => void
-  watchFileObliterate: () => void
-  readFile: (path: string) => ReturnType<fs.readFile>
+  readFile: typeof fs.readFile
+  watchFileOff: (path: string, key: string) => void
   writeFile: (
     path: string,
     data: string | Uint8Array
@@ -68,11 +68,15 @@ export interface IElectronAPI {
     }
   }
   kittycad: (access: string, args: any) => any
-  listMachines: () => Promise<MachinesListing>
+  listMachines: (machineApiIp: string) => 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
 }
 

make-release.sh

@@ -70,7 +70,7 @@ echo ""
 echo "Suggested changelog:"
 echo "\`\`\`"
 echo "## What's Changed"
-git log $(git describe --tags --abbrev=0)..HEAD --oneline --pretty=format:%s | grep -v Bump | grep -v 'Cut release v' | awk '{print "* "toupper(substr($0,0,1))substr($0,2)}'
+git log $(git describe --tags --match="v[0-9]*" --abbrev=0)..HEAD --oneline --pretty=format:%s | grep -v Bump | grep -v 'Cut release v' | awk '{print "* "toupper(substr($0,0,1))substr($0,2)}'
 echo ""
 echo "**Full Changelog**: https://github.com/KittyCAD/modeling-app/compare/${latest_tag}...${new_version}"
 echo "\`\`\`"

openapi/machine-api.json

@@ -36,38 +36,319 @@
         "description": "Extra machine-specific information regarding a connected machine.",
         "oneOf": [
           {
-            "additionalProperties": false,
             "properties": {
-              "Moonraker": {
-                "type": "object"
+              "type": {
+                "enum": [
+                  "moonraker"
+                ],
+                "type": "string"
               }
             },
             "required": [
-              "Moonraker"
+              "type"
             ],
             "type": "object"
           },
           {
-            "additionalProperties": false,
             "properties": {
-              "Usb": {
-                "type": "object"
+              "type": {
+                "enum": [
+                  "usb"
+                ],
+                "type": "string"
               }
             },
             "required": [
-              "Usb"
+              "type"
             ],
             "type": "object"
           },
           {
-            "additionalProperties": false,
             "properties": {
-              "Bambu": {
-                "type": "object"
+              "current_stage": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/Stage"
+                  }
+                ],
+                "description": "The current stage of the machine as defined by Bambu which can include errors, etc.",
+                "nullable": true
+              },
+              "nozzle_diameter": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/NozzleDiameter"
+                  }
+                ],
+                "description": "The nozzle diameter of the machine."
+              },
+              "type": {
+                "enum": [
+                  "bambu"
+                ],
+                "type": "string"
               }
             },
             "required": [
-              "Bambu"
+              "nozzle_diameter",
+              "type"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "FdmHardwareConfiguration": {
+        "description": "Configuration for a FDM-based printer.",
+        "properties": {
+          "filaments": {
+            "description": "The filaments the printer has access to.",
+            "items": {
+              "$ref": "#/components/schemas/Filament"
+            },
+            "type": "array"
+          },
+          "loaded_filament_idx": {
+            "description": "The currently loaded filament index.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          },
+          "nozzle_diameter": {
+            "description": "Diameter of the extrusion nozzle, in mm.",
+            "format": "double",
+            "type": "number"
+          }
+        },
+        "required": [
+          "filaments",
+          "nozzle_diameter"
+        ],
+        "type": "object"
+      },
+      "Filament": {
+        "description": "Information about the filament being used in a FDM printer.",
+        "properties": {
+          "color": {
+            "description": "The color (as hex without the `#`) of the filament, this is likely specific to the manufacturer.",
+            "maxLength": 6,
+            "minLength": 6,
+            "nullable": true,
+            "type": "string"
+          },
+          "material": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/FilamentMaterial"
+              }
+            ],
+            "description": "The material that the filament is made of."
+          },
+          "name": {
+            "description": "The name of the filament, this is likely specfic to the manufacturer.",
+            "nullable": true,
+            "type": "string"
+          }
+        },
+        "required": [
+          "material"
+        ],
+        "type": "object"
+      },
+      "FilamentMaterial": {
+        "description": "The material that the filament is made of.",
+        "oneOf": [
+          {
+            "description": "Polylactic acid based plastics",
+            "properties": {
+              "type": {
+                "enum": [
+                  "pla"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Pla support",
+            "properties": {
+              "type": {
+                "enum": [
+                  "pla_support"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "acrylonitrile butadiene styrene based plastics",
+            "properties": {
+              "type": {
+                "enum": [
+                  "abs"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "polyethylene terephthalate glycol based plastics",
+            "properties": {
+              "type": {
+                "enum": [
+                  "petg"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "unsuprisingly, nylon based",
+            "properties": {
+              "type": {
+                "enum": [
+                  "nylon"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "thermoplastic polyurethane based urethane material",
+            "properties": {
+              "type": {
+                "enum": [
+                  "tpu"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "polyvinyl alcohol based material",
+            "properties": {
+              "type": {
+                "enum": [
+                  "pva"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "high impact polystyrene based material",
+            "properties": {
+              "type": {
+                "enum": [
+                  "hips"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "composite material with stuff in other stuff, something like PLA mixed with carbon fiber, kevlar, or fiberglass",
+            "properties": {
+              "type": {
+                "enum": [
+                  "composite"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Unknown material",
+            "properties": {
+              "type": {
+                "enum": [
+                  "unknown"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          }
+        ]
+      },
+      "HardwareConfiguration": {
+        "description": "The hardware configuration of a machine.",
+        "oneOf": [
+          {
+            "description": "No configuration is possible. This isn't the same conceptually as an `Option<HardwareConfiguration>`, because this indicates we positively know there is no possible configuration changes that are possible with this method of manufcture.",
+            "properties": {
+              "type": {
+                "enum": [
+                  "none"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "type"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Hardware configuration specific to FDM based printers",
+            "properties": {
+              "config": {
+                "allOf": [
+                  {
+                    "$ref": "#/components/schemas/FdmHardwareConfiguration"
+                  }
+                ],
+                "description": "The configuration for the FDM printer."
+              },
+              "type": {
+                "enum": [
+                  "fdm"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "config",
+              "type"
             ],
             "type": "object"
           }
@@ -85,6 +366,14 @@
             "description": "Additional, per-machine information which is specific to the underlying machine type.",
             "nullable": true
           },
+          "hardware_configuration": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/HardwareConfiguration"
+              }
+            ],
+            "description": "Information about how the Machine is currently configured."
+          },
           "id": {
             "description": "Machine Identifier (ID) for the specific Machine.",
             "type": "string"
@@ -114,6 +403,12 @@
             "description": "Maximum part size that can be manufactured by this device. This may be some sort of theoretical upper bound, getting close to this limit seems like maybe a bad idea.\n\nThis may be `None` if the maximum size is not knowable by the Machine API.\n\nWhat \"close\" means is up to you!",
             "nullable": true
           },
+          "progress": {
+            "description": "Progress of the current print, if printing.",
+            "format": "double",
+            "nullable": true,
+            "type": "number"
+          },
           "state": {
             "allOf": [
               {
@@ -124,6 +419,7 @@
           }
         },
         "required": [
+          "hardware_configuration",
           "id",
           "machine_type",
           "make_model",
@@ -157,57 +453,111 @@
         "oneOf": [
           {
             "description": "If a print state can not be resolved at this time, an Unknown may be returned.",
-            "enum": [
-              "Unknown"
-            ],
-            "type": "string"
-          },
-          {
-            "description": "Idle, and ready for another job.",
-            "enum": [
-              "Idle"
-            ],
-            "type": "string"
-          },
-          {
-            "description": "Running a job -- 3D printing or CNC-ing a part.",
-            "enum": [
-              "Running"
-            ],
-            "type": "string"
-          },
-          {
-            "description": "Machine is currently offline or unreachable.",
-            "enum": [
-              "Offline"
-            ],
-            "type": "string"
-          },
-          {
-            "description": "Job is underway but halted, waiting for some action to take place.",
-            "enum": [
-              "Paused"
-            ],
-            "type": "string"
-          },
-          {
-            "description": "Job is finished, but waiting manual action to move back to Idle.",
-            "enum": [
-              "Complete"
-            ],
-            "type": "string"
-          },
-          {
-            "additionalProperties": false,
-            "description": "The printer has failed and is in an unknown state that may require manual attention to resolve. The inner value is a human readable description of what specifically has failed.",
             "properties": {
-              "Failed": {
-                "nullable": true,
+              "state": {
+                "enum": [
+                  "unknown"
+                ],
                 "type": "string"
               }
             },
             "required": [
-              "Failed"
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Idle, and ready for another job.",
+            "properties": {
+              "state": {
+                "enum": [
+                  "idle"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Running a job -- 3D printing or CNC-ing a part.",
+            "properties": {
+              "state": {
+                "enum": [
+                  "running"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Machine is currently offline or unreachable.",
+            "properties": {
+              "state": {
+                "enum": [
+                  "offline"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Job is underway but halted, waiting for some action to take place.",
+            "properties": {
+              "state": {
+                "enum": [
+                  "paused"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "Job is finished, but waiting manual action to move back to Idle.",
+            "properties": {
+              "state": {
+                "enum": [
+                  "complete"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
+            ],
+            "type": "object"
+          },
+          {
+            "description": "The printer has failed and is in an unknown state that may require manual attention to resolve. The inner value is a human readable description of what specifically has failed.",
+            "properties": {
+              "message": {
+                "description": "A human-readable message describing the failure.",
+                "nullable": true,
+                "type": "string"
+              },
+              "state": {
+                "enum": [
+                  "failed"
+                ],
+                "type": "string"
+              }
+            },
+            "required": [
+              "state"
             ],
             "type": "object"
           }
@@ -219,21 +569,54 @@
           {
             "description": "Use light to cure a resin to build up layers.",
             "enum": [
-              "Stereolithography"
+              "stereolithography"
             ],
             "type": "string"
           },
           {
             "description": "Fused Deposition Modeling, layers of melted plastic.",
             "enum": [
-              "FusedDeposition"
+              "fused_deposition"
             ],
             "type": "string"
           },
           {
             "description": "\"Computer numerical control\" - machine that grinds away material from a hunk of material to construct a part.",
             "enum": [
-              "Cnc"
+              "cnc"
+            ],
+            "type": "string"
+          }
+        ]
+      },
+      "NozzleDiameter": {
+        "description": "A nozzle diameter.",
+        "oneOf": [
+          {
+            "description": "0.2mm.",
+            "enum": [
+              "0.2"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "0.4mm.",
+            "enum": [
+              "0.4"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "0.6mm.",
+            "enum": [
+              "0.6"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "0.8mm.",
+            "enum": [
+              "0.8"
             ],
             "type": "string"
           }
@@ -284,6 +667,15 @@
           "machine_id": {
             "description": "The machine id to print to.",
             "type": "string"
+          },
+          "slicer_configuration": {
+            "allOf": [
+              {
+                "$ref": "#/components/schemas/SlicerConfiguration"
+              }
+            ],
+            "description": "Requested design-specific slicer configurations.",
+            "nullable": true
           }
         },
         "required": [
@@ -292,6 +684,283 @@
         ],
         "type": "object"
       },
+      "SlicerConfiguration": {
+        "description": "The slicer configuration is a set of parameters that are passed to the slicer to control how the gcode is generated.",
+        "properties": {
+          "filament_idx": {
+            "description": "The filament to use for the print.",
+            "format": "uint",
+            "minimum": 0,
+            "nullable": true,
+            "type": "integer"
+          }
+        },
+        "type": "object"
+      },
+      "Stage": {
+        "description": "The print stage. These come from: https://github.com/SoftFever/OrcaSlicer/blob/431978baf17961df90f0d01871b0ad1d839d7f5d/src/slic3r/GUI/DeviceManager.cpp#L78",
+        "oneOf": [
+          {
+            "description": "Nothing.",
+            "enum": [
+              "nothing"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Empty.",
+            "enum": [
+              "empty"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Auto bed leveling.",
+            "enum": [
+              "auto_bed_leveling"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Heatbed preheating.",
+            "enum": [
+              "heatbed_preheating"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Sweeping XY mech mode.",
+            "enum": [
+              "sweeping_xy_mech_mode"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Changing filament.",
+            "enum": [
+              "changing_filament"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "M400 pause.",
+            "enum": [
+              "m400_pause"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to filament runout.",
+            "enum": [
+              "paused_due_to_filament_runout"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Heating hotend.",
+            "enum": [
+              "heating_hotend"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Calibrating extrusion.",
+            "enum": [
+              "calibrating_extrusion"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Scanning bed surface.",
+            "enum": [
+              "scanning_bed_surface"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Inspecting first layer.",
+            "enum": [
+              "inspecting_first_layer"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Identifying build plate type.",
+            "enum": [
+              "identifying_build_plate_type"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Calibrating micro lidar.",
+            "enum": [
+              "calibrating_micro_lidar"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Homing toolhead.",
+            "enum": [
+              "homing_toolhead"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Cleaning nozzle tip.",
+            "enum": [
+              "cleaning_nozzle_tip"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Checking extruder temperature.",
+            "enum": [
+              "checking_extruder_temperature"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Printing was paused by the user.",
+            "enum": [
+              "printing_was_paused_by_the_user"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Pause of front cover falling.",
+            "enum": [
+              "pause_of_front_cover_falling"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Calibrating micro lidar.",
+            "enum": [
+              "calibrating_micro_lidar2"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Calibrating extrusion flow.",
+            "enum": [
+              "calibrating_extrusion_flow"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to nozzle temperature malfunction.",
+            "enum": [
+              "paused_due_to_nozzle_temperature_malfunction"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to heat bed temperature malfunction.",
+            "enum": [
+              "paused_due_to_heat_bed_temperature_malfunction"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Filament unloading.",
+            "enum": [
+              "filament_unloading"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Skip step pause.",
+            "enum": [
+              "skip_step_pause"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Filament loading.",
+            "enum": [
+              "filament_loading"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Motor noise calibration.",
+            "enum": [
+              "motor_noise_calibration"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to AMS lost.",
+            "enum": [
+              "paused_due_to_ams_lost"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to low speed of the heat break fan.",
+            "enum": [
+              "paused_due_to_low_speed_of_the_heat_break_fan"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused due to chamber temperature control error.",
+            "enum": [
+              "paused_due_to_chamber_temperature_control_error"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Cooling chamber.",
+            "enum": [
+              "cooling_chamber"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Paused by the Gcode inserted by the user.",
+            "enum": [
+              "paused_by_the_gcode_inserted_by_the_user"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Motor noise showoff.",
+            "enum": [
+              "motor_noise_showoff"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Nozzle filament covered detected pause.",
+            "enum": [
+              "nozzle_filament_covered_detected_pause"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Cutter error pause.",
+            "enum": [
+              "cutter_error_pause"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "First layer error pause.",
+            "enum": [
+              "first_layer_error_pause"
+            ],
+            "type": "string"
+          },
+          {
+            "description": "Nozzle clog pause.",
+            "enum": [
+              "nozzle_clog_pause"
+            ],
+            "type": "string"
+          }
+        ]
+      },
       "Volume": {
         "description": "Set of three values to represent the extent of a 3-D Volume. This contains the width, depth, and height values, generally used to represent some maximum or minimum.\n\nAll measurements are in millimeters.",
         "properties": {
@@ -327,7 +996,7 @@
     },
     "description": "",
     "title": "machine-api",
-    "version": "0.1.0"
+    "version": "0.1.1"
   },
   "openapi": "3.0.3",
   "paths": {
@@ -425,6 +1094,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 +1189,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": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "zoo-modeling-app",
-  "version": "0.25.5",
+  "version": "0.26.2",
   "private": true,
   "productName": "Zoo Modeling App",
   "author": {
@@ -26,7 +26,7 @@
     "@fortawesome/react-fontawesome": "^0.2.0",
     "@headlessui/react": "^1.7.19",
     "@headlessui/tailwindcss": "^0.2.0",
-    "@kittycad/lib": "^2.0.1",
+    "@kittycad/lib": "2.0.7",
     "@lezer/highlight": "^1.2.1",
     "@lezer/lr": "^1.4.1",
     "@react-hook/resize-observer": "^2.0.1",
@@ -36,6 +36,7 @@
     "@xstate/inspect": "^0.8.0",
     "@xstate/react": "^4.1.1",
     "bonjour-service": "^1.2.1",
+    "chokidar": "^4.0.1",
     "codemirror": "^6.0.1",
     "decamelize": "^6.0.0",
     "electron-squirrel-startup": "^1.0.1",
@@ -160,7 +161,7 @@
     "@types/isomorphic-fetch": "^0.0.39",
     "@types/minimist": "^1.2.5",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^22.5.0",
+    "@types/node": "^22.7.8",
     "@types/pixelmatch": "^5.2.6",
     "@types/pngjs": "^6.0.4",
     "@types/react": "^18.3.4",

src/Router.tsx

@@ -21,6 +21,7 @@ import { WasmErrBanner } from 'components/WasmErrBanner'
 import { CommandBar } from 'components/CommandBar/CommandBar'
 import ModelingMachineProvider from 'components/ModelingMachineProvider'
 import FileMachineProvider from 'components/FileMachineProvider'
+import { MachineManagerProvider } from 'components/MachineManagerProvider'
 import { PATHS } from 'lib/paths'
 import {
   fileLoader,
@@ -49,6 +50,7 @@ const router = createRouter([
   {
     loader: settingsLoader,
     id: PATHS.INDEX,
+    // TODO: Re-evaluate if this is true
     /* Make sure auth is the outermost provider or else we will have
      * inefficient re-renders, use the react profiler to see. */
     element: (
@@ -57,7 +59,9 @@ const router = createRouter([
           <LspProvider>
             <KclContextProvider>
               <AppStateProvider>
-                <Outlet />
+                <MachineManagerProvider>
+                  <Outlet />
+                </MachineManagerProvider>
               </AppStateProvider>
             </KclContextProvider>
           </LspProvider>

src/clientSideScene/CameraControls.ts

@@ -64,6 +64,27 @@ export type ReactCameraProperties =
 
 const lastCmdDelay = 50
 
+class CameraRateLimiter {
+  lastSend?: Date = undefined
+  rateLimitMs: number = 16 //60 FPS
+
+  send = (f: () => void) => {
+    let now = new Date()
+
+    if (
+      this.lastSend === undefined ||
+      now.getTime() - this.lastSend.getTime() > this.rateLimitMs
+    ) {
+      f()
+      this.lastSend = now
+    }
+  }
+
+  reset = () => {
+    this.lastSend = undefined
+  }
+}
+
 export class CameraControls {
   engineCommandManager: EngineCommandManager
   syncDirection: 'clientToEngine' | 'engineToClient' = 'engineToClient'
@@ -71,15 +92,15 @@ export class CameraControls {
   target: Vector3
   domElement: HTMLCanvasElement
   isDragging: boolean
+  wasDragging: boolean
   mouseDownPosition: Vector2
   mouseNewPosition: Vector2
   rotationSpeed = 0.3
   enableRotate = true
   enablePan = true
   enableZoom = true
-  zoomDataFromLastFrame?: number = undefined
-  // holds coordinates, and interaction
-  moveDataFromLastFrame?: [number, number, string] = undefined
+  moveSender: CameraRateLimiter = new CameraRateLimiter()
+  zoomSender: CameraRateLimiter = new CameraRateLimiter()
   lastPerspectiveFov: number = 45
   pendingZoom: number | null = null
   pendingRotation: Vector2 | null = null
@@ -171,6 +192,36 @@ export class CameraControls {
     }
   }
 
+  doMove = (interaction: any, coordinates: any) => {
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.engineCommandManager.sendSceneCommand({
+      type: 'modeling_cmd_req',
+      cmd: {
+        type: 'camera_drag_move',
+        interaction: interaction,
+        window: {
+          x: coordinates[0],
+          y: coordinates[1],
+        },
+      },
+      cmd_id: uuidv4(),
+    })
+  }
+
+  doZoom = (zoom: number) => {
+    this.handleStart()
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    this.engineCommandManager.sendSceneCommand({
+      type: 'modeling_cmd_req',
+      cmd: {
+        type: 'default_camera_zoom',
+        magnitude: (-1 * zoom) / window.devicePixelRatio,
+      },
+      cmd_id: uuidv4(),
+    })
+    this.handleEnd()
+  }
+
   constructor(
     isOrtho = false,
     domElement: HTMLCanvasElement,
@@ -183,6 +234,7 @@ export class CameraControls {
     this.target = new Vector3()
     this.domElement = domElement
     this.isDragging = false
+    this.wasDragging = false
     this.mouseDownPosition = new Vector2()
     this.mouseNewPosition = new Vector2()
 
@@ -258,49 +310,6 @@ export class CameraControls {
       this.onCameraChange()
     }
 
-    // Our stream is never more than 60fps.
-    // We can get away with capping our "virtual fps" to 60 then.
-    const FPS_VIRTUAL = 60
-
-    const doZoom = () => {
-      if (this.zoomDataFromLastFrame !== undefined) {
-        this.handleStart()
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.engineCommandManager.sendSceneCommand({
-          type: 'modeling_cmd_req',
-          cmd: {
-            type: 'default_camera_zoom',
-            magnitude:
-              (-1 * this.zoomDataFromLastFrame) / window.devicePixelRatio,
-          },
-          cmd_id: uuidv4(),
-        })
-        this.handleEnd()
-      }
-      this.zoomDataFromLastFrame = undefined
-    }
-    setInterval(doZoom, 1000 / FPS_VIRTUAL)
-
-    const doMove = () => {
-      if (this.moveDataFromLastFrame !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.engineCommandManager.sendSceneCommand({
-          type: 'modeling_cmd_req',
-          cmd: {
-            type: 'camera_drag_move',
-            interaction: this.moveDataFromLastFrame[2] as any,
-            window: {
-              x: this.moveDataFromLastFrame[0],
-              y: this.moveDataFromLastFrame[1],
-            },
-          },
-          cmd_id: uuidv4(),
-        })
-      }
-      this.moveDataFromLastFrame = undefined
-    }
-    setInterval(doMove, 1000 / FPS_VIRTUAL)
-
     setTimeout(() => {
       this.engineCommandManager.subscribeTo({
         event: 'camera_drag_end',
@@ -356,6 +365,8 @@ export class CameraControls {
   onMouseDown = (event: PointerEvent) => {
     this.domElement.setPointerCapture(event.pointerId)
     this.isDragging = true
+    // Reset the wasDragging flag to false when starting a new drag
+    this.wasDragging = false
     this.mouseDownPosition.set(event.clientX, event.clientY)
     let interaction = this.getInteractionType(event)
     if (interaction === 'none') return
@@ -385,11 +396,18 @@ export class CameraControls {
       const interaction = this.getInteractionType(event)
       if (interaction === 'none') return
 
+      // If there's a valid interaction and the mouse is moving,
+      // our past (and current) interaction was a drag.
+      this.wasDragging = true
+
       if (this.syncDirection === 'engineToClient') {
-        this.moveDataFromLastFrame = [event.clientX, event.clientY, interaction]
+        this.moveSender.send(() => {
+          this.doMove(interaction, [event.clientX, event.clientY])
+        })
         return
       }
 
+      // else "clientToEngine" (Sketch Mode) or forceUpdate
       // Implement camera movement logic here based on deltaMove
       // For example, for rotating the camera around the target:
       if (interaction === 'rotate') {
@@ -418,6 +436,9 @@ export class CameraControls {
        * under the cursor. This recently moved from being handled in App.tsx.
        * This might not be the right spot, but it is more consolidated.
        */
+
+      // Clear any previous drag state
+      this.wasDragging = false
       if (this.syncDirection === 'engineToClient') {
         const newCmdId = uuidv4()
 
@@ -459,7 +480,9 @@ export class CameraControls {
 
     if (this.syncDirection === 'engineToClient') {
       if (interaction === 'zoom') {
-        this.zoomDataFromLastFrame = event.deltaY
+        this.zoomSender.send(() => {
+          this.doZoom(event.deltaY)
+        })
       } else {
         // This case will get handled when we add pan and rotate using Apple trackpad.
         console.error(
@@ -893,6 +916,7 @@ export class CameraControls {
         type: 'zoom_to_fit',
         object_ids: [], // leave empty to zoom to all objects
         padding: 0.2, // padding around the objects
+        animated: false, // don't animate the zoom for now
       },
     })
   }

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

@@ -338,6 +338,11 @@ export class SceneEntities {
     sceneInfra.setCallbacks({
       onClick: async (args) => {
         if (!args) return
+        // If there is a valid camera interaction that matches, do that instead
+        const interaction = sceneInfra.camControls.getInteractionType(
+          args.mouseEvent
+        )
+        if (interaction !== 'none') return
         if (args.mouseEvent.which !== 1) return
         const { intersectionPoint } = args
         if (!intersectionPoint?.twoD || !sketchDetails?.sketchPathToNode) return
@@ -391,12 +396,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,
@@ -405,7 +412,7 @@ export class SceneEntities {
     if (err(sketch)) return Promise.reject(sketch)
     if (!sketch) return Promise.reject('sketch not found')
 
-    if (!isArray(sketch?.value))
+    if (!isArray(sketch?.paths))
       return {
         truncatedAst,
         programMemoryOverride,
@@ -433,7 +440,7 @@ export class SceneEntities {
       maybeModdedAst,
       sketch.start.__geoMeta.sourceRange
     )
-    if (sketch?.value?.[0]?.type !== 'Circle') {
+    if (sketch?.paths?.[0]?.type !== 'Circle') {
       const _profileStart = createProfileStartHandle({
         from: sketch.start.from,
         id: sketch.start.__geoMeta.id,
@@ -449,16 +456,16 @@ export class SceneEntities {
       this.activeSegments[JSON.stringify(segPathToNode)] = _profileStart
     }
     const callbacks: (() => SegmentOverlayPayload | null)[] = []
-    sketch.value.forEach((segment, index) => {
+    sketch.paths.forEach((segment, index) => {
       let segPathToNode = getNodePathFromSourceRange(
         maybeModdedAst,
         segment.__geoMeta.sourceRange
       )
       if (
         draftExpressionsIndices &&
-        (sketch.value[index - 1] || sketch.start)
+        (sketch.paths[index - 1] || sketch.start)
       ) {
-        const previousSegment = sketch.value[index - 1] || sketch.start
+        const previousSegment = sketch.paths[index - 1] || sketch.start
         const previousSegmentPathToNode = getNodePathFromSourceRange(
           maybeModdedAst,
           previousSegment.__geoMeta.sourceRange
@@ -509,7 +516,7 @@ export class SceneEntities {
               to: segment.to,
             }
       const result = initSegment({
-        prevSegment: sketch.value[index - 1],
+        prevSegment: sketch.paths[index - 1],
         callExpName,
         input,
         id: segment.__geoMeta.id,
@@ -608,9 +615,9 @@ export class SceneEntities {
       variableDeclarationName
     )
     if (err(sg)) return Promise.reject(sg)
-    const lastSeg = sg?.value?.slice(-1)[0] || sg.start
+    const lastSeg = sg?.paths?.slice(-1)[0] || sg.start
 
-    const index = sg.value.length // because we've added a new segment that's not in the memory yet, no need for `-1`
+    const index = sg.paths.length // because we've added a new segment that's not in the memory yet, no need for `-1`
     const mod = addNewSketchLn({
       node: _ast,
       programMemory: kclManager.programMemory,
@@ -643,7 +650,13 @@ export class SceneEntities {
     sceneInfra.setCallbacks({
       onClick: async (args) => {
         if (!args) return
+        // If there is a valid camera interaction that matches, do that instead
+        const interaction = sceneInfra.camControls.getInteractionType(
+          args.mouseEvent
+        )
+        if (interaction !== 'none') return
         if (args.mouseEvent.which !== 1) return
+
         const { intersectionPoint } = args
         let intersection2d = intersectionPoint?.twoD
         const profileStart = args.intersects
@@ -652,7 +665,7 @@ export class SceneEntities {
 
         let modifiedAst
         if (profileStart) {
-          const lastSegment = sketch.value.slice(-1)[0]
+          const lastSegment = sketch.paths.slice(-1)[0]
           modifiedAst = addCallExpressionsToPipe({
             node: kclManager.ast,
             programMemory: kclManager.programMemory,
@@ -684,7 +697,7 @@ export class SceneEntities {
           })
           if (trap(modifiedAst)) return Promise.reject(modifiedAst)
         } else if (intersection2d) {
-          const lastSegment = sketch.value.slice(-1)[0]
+          const lastSegment = sketch.paths.slice(-1)[0]
           const tmp = addNewSketchLn({
             node: kclManager.ast,
             programMemory: kclManager.programMemory,
@@ -733,7 +746,6 @@ export class SceneEntities {
           },
         })
       },
-      ...this.mouseEnterLeaveCallbacks(),
     })
   }
   setupDraftRectangle = async (
@@ -801,19 +813,21 @@ 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),
           variableDeclarationName
         )
         if (err(sketch)) return Promise.reject(sketch)
-        const sgPaths = sketch.value
+        const sgPaths = sketch.paths
         const orthoFactor = orthoScale(sceneInfra.camControls.camera)
 
         this.updateSegment(sketch.start, 0, 0, _ast, orthoFactor, sketch)
@@ -822,6 +836,11 @@ export class SceneEntities {
         )
       },
       onClick: async (args) => {
+        // If there is a valid camera interaction that matches, do that instead
+        const interaction = sceneInfra.camControls.getInteractionType(
+          args.mouseEvent
+        )
+        if (interaction !== 'none') return
         // Commit the rectangle to the full AST/code and return to sketch.idle
         const cornerPoint = args.intersectionPoint?.twoD
         if (!cornerPoint || args.mouseEvent.button !== 0) return
@@ -848,12 +867,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
@@ -862,7 +883,7 @@ export class SceneEntities {
             variableDeclarationName
           )
           if (err(sketch)) return
-          const sgPaths = sketch.value
+          const sgPaths = sketch.paths
           const orthoFactor = orthoScale(sceneInfra.camControls.camera)
 
           // Update the starting segment of the THREEjs scene
@@ -965,19 +986,21 @@ 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),
           variableDeclarationName
         )
         if (err(sketch)) return
-        const sgPaths = sketch.value
+        const sgPaths = sketch.paths
         const orthoFactor = orthoScale(sceneInfra.camControls.camera)
 
         this.updateSegment(sketch.start, 0, 0, _ast, orthoFactor, sketch)
@@ -986,6 +1009,11 @@ export class SceneEntities {
         )
       },
       onClick: async (args) => {
+        // If there is a valid camera interaction that matches, do that instead
+        const interaction = sceneInfra.camControls.getInteractionType(
+          args.mouseEvent
+        )
+        if (interaction !== 'none') return
         // Commit the rectangle to the full AST/code and return to sketch.idle
         const cornerPoint = args.intersectionPoint?.twoD
         if (!cornerPoint || args.mouseEvent.button !== 0) return
@@ -1097,7 +1125,7 @@ export class SceneEntities {
 
           const pipeIndex = pathToNode[pathToNodeIndex + 1][0] as number
           if (addingNewSegmentStatus === 'nothing') {
-            const prevSegment = sketch.value[pipeIndex - 2]
+            const prevSegment = sketch.paths[pipeIndex - 2]
             const mod = addNewSketchLn({
               node: kclManager.ast,
               programMemory: kclManager.programMemory,
@@ -1149,6 +1177,11 @@ export class SceneEntities {
       },
       onMove: () => {},
       onClick: (args) => {
+        // If there is a valid camera interaction that matches, do that instead
+        const interaction = sceneInfra.camControls.getInteractionType(
+          args.mouseEvent
+        )
+        if (interaction !== 'none') return
         if (args?.mouseEvent.which !== 1) return
         if (!args || !args.selected) {
           sceneInfra.modelingSend({
@@ -1317,12 +1350,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)
@@ -1335,7 +1370,7 @@ export class SceneEntities {
       }
       if (!sketch) return
 
-      const sgPaths = sketch.value
+      const sgPaths = sketch.paths
       const orthoFactor = orthoScale(sceneInfra.camControls.camera)
 
       this.updateSegment(
@@ -1383,7 +1418,7 @@ export class SceneEntities {
       modifiedAst,
       segment.__geoMeta.sourceRange
     )
-    const sgPaths = sketch.value
+    const sgPaths = sketch.paths
     const originalPathToNodeStr = JSON.stringify(segPathToNode)
     segPathToNode[1][0] = varDecIndex
     const pathToNodeStr = JSON.stringify(segPathToNode)
@@ -1691,7 +1726,7 @@ function prepareTruncatedMemoryAndAst(
     variableDeclarationName
   )
   if (err(sg)) return sg
-  const lastSeg = sg?.value.slice(-1)[0]
+  const lastSeg = sg?.paths.slice(-1)[0]
   if (draftSegment) {
     // truncatedAst needs to setup with another segment at the end
     let newSegment

src/clientSideScene/sceneInfra.ts

@@ -213,7 +213,7 @@ export class SceneInfra {
     to: Coords2d
     angle?: number
   }): SegmentOverlayPayload | null {
-    if (group.userData.pathToNode && arrowGroup) {
+    if (!group.userData.draft && group.userData.pathToNode && arrowGroup) {
       const vector = new Vector3(0, 0, 0)
 
       // Get the position of the object3D in world space

src/clientSideScene/segments.ts

@@ -58,7 +58,7 @@ import { err } from 'lib/trap'
 
 interface CreateSegmentArgs {
   input: SegmentInputs
-  prevSegment: Sketch['value'][number]
+  prevSegment: Sketch['paths'][number]
   id: string
   pathToNode: PathToNode
   isDraftSegment?: boolean
@@ -72,7 +72,7 @@ interface CreateSegmentArgs {
 
 interface UpdateSegmentArgs {
   input: SegmentInputs
-  prevSegment: Sketch['value'][number]
+  prevSegment: Sketch['paths'][number]
   group: Group
   sceneInfra: SceneInfra
   scale?: number
@@ -147,6 +147,7 @@ class StraightSegment implements SegmentUtils {
     segmentGroup.name = STRAIGHT_SEGMENT
     segmentGroup.userData = {
       type: STRAIGHT_SEGMENT,
+      draft: isDraftSegment,
       id,
       from,
       to,
@@ -347,6 +348,7 @@ class TangentialArcToSegment implements SegmentUtils {
     mesh.name = meshName
     group.userData = {
       type: TANGENTIAL_ARC_TO_SEGMENT,
+      draft: isDraftSegment,
       id,
       from,
       to,
@@ -515,11 +517,18 @@ class CircleSegment implements SegmentUtils {
     const meshType = isDraftSegment ? CIRCLE_SEGMENT_DASH : CIRCLE_SEGMENT_BODY
     const arrowGroup = createArrowhead(scale, theme, color)
     const circleCenterGroup = createCircleCenterHandle(scale, theme, color)
+    // A radius indicator that appears from the center to the perimeter
+    const radiusIndicatorGroup = createLengthIndicator({
+      from: center,
+      to: [center[0] + radius, center[1]],
+      scale,
+    })
 
     arcMesh.userData.type = meshType
     arcMesh.name = meshType
     group.userData = {
       type: CIRCLE_SEGMENT,
+      draft: isDraftSegment,
       id,
       from,
       radius,
@@ -532,7 +541,7 @@ class CircleSegment implements SegmentUtils {
     }
     group.name = CIRCLE_SEGMENT
 
-    group.add(arcMesh, arrowGroup, circleCenterGroup)
+    group.add(arcMesh, arrowGroup, circleCenterGroup, radiusIndicatorGroup)
     const updateOverlaysCallback = this.update({
       prevSegment,
       input,
@@ -564,6 +573,9 @@ class CircleSegment implements SegmentUtils {
     group.userData.radius = radius
     group.userData.prevSegment = prevSegment
     const arrowGroup = group.getObjectByName(ARROWHEAD) as Group
+    const radiusLengthIndicator = group.getObjectByName(
+      SEGMENT_LENGTH_LABEL
+    ) as Group
     const circleCenterHandle = group.getObjectByName(
       CIRCLE_CENTER_HANDLE
     ) as Group
@@ -581,11 +593,14 @@ class CircleSegment implements SegmentUtils {
     }
 
     if (arrowGroup) {
-      arrowGroup.position.set(
-        center[0] + Math.cos(Math.PI / 4) * radius,
-        center[1] + Math.sin(Math.PI / 4) * radius,
-        0
-      )
+      // The arrowhead is placed at the perimeter of the circle,
+      // pointing up and to the right
+      const arrowPoint = {
+        x: center[0] + Math.cos(Math.PI / 4) * radius,
+        y: center[1] + Math.sin(Math.PI / 4) * radius,
+      }
+
+      arrowGroup.position.set(arrowPoint.x, arrowPoint.y, 0)
 
       const arrowheadAngle = Math.PI / 4
       arrowGroup.quaternion.setFromUnitVectors(
@@ -596,6 +611,31 @@ class CircleSegment implements SegmentUtils {
       arrowGroup.visible = isHandlesVisible
     }
 
+    if (radiusLengthIndicator) {
+      // The radius indicator is placed at the midpoint of the radius,
+      // at a 45 degree CCW angle from the positive X-axis
+      const indicatorPoint = {
+        x: center[0] + (Math.cos(Math.PI / 4) * radius) / 2,
+        y: center[1] + (Math.sin(Math.PI / 4) * radius) / 2,
+      }
+      const labelWrapper = radiusLengthIndicator.getObjectByName(
+        SEGMENT_LENGTH_LABEL_TEXT
+      ) as CSS2DObject
+      const labelWrapperElem = labelWrapper.element as HTMLDivElement
+      const label = labelWrapperElem.children[0] as HTMLParagraphElement
+      label.innerText = `${roundOff(radius)}`
+      label.classList.add(SEGMENT_LENGTH_LABEL_TEXT)
+      const isPlaneBackFace = center[0] > indicatorPoint.x
+      label.style.setProperty(
+        '--degree',
+        `${isPlaneBackFace ? '45' : '-45'}deg`
+      )
+      label.style.setProperty('--x', `0px`)
+      label.style.setProperty('--y', `0px`)
+      labelWrapper.position.set(indicatorPoint.x, indicatorPoint.y, 0)
+      radiusLengthIndicator.visible = isHandlesVisible
+    }
+
     if (circleCenterHandle) {
       circleCenterHandle.position.set(center[0], center[1], 0)
       circleCenterHandle.scale.set(scale, scale, scale)

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/CommandBar/CommandArgOptionInput.tsx

@@ -135,7 +135,9 @@ function CommandArgOptionInput({
           <Combobox.Input
             id="option-input"
             ref={inputRef}
-            onChange={(event) => setQuery(event.target.value)}
+            onChange={(event) =>
+              !event.target.disabled && setQuery(event.target.value)
+            }
             className="flex-grow px-2 py-1 border-b border-b-chalkboard-100 dark:border-b-chalkboard-80 !bg-transparent focus:outline-none"
             onKeyDown={(event) => {
               if (event.metaKey && event.key === 'k')
@@ -175,9 +177,18 @@ function CommandArgOptionInput({
             <Combobox.Option
               key={option.name}
               value={option}
+              disabled={option.disabled}
               className="flex items-center gap-2 px-4 py-1 first:mt-2 last:mb-2 ui-active:bg-primary/10 dark:ui-active:bg-chalkboard-90"
             >
-              <p className="flex-grow">{option.name} </p>
+              <p
+                className={`flex-grow ${
+                  (option.disabled &&
+                    'text-chalkboard-70 dark:text-chalkboard-50 cursor-not-allowed') ||
+                  ''
+                }`}
+              >
+                {option.name}
+              </p>
               {option.value === currentOption?.value && (
                 <small className="text-chalkboard-70 dark:text-chalkboard-50">
                   current

src/components/CommandBar/CommandBarSelectionInput.tsx

@@ -91,7 +91,7 @@ function CommandBarSelectionInput({
     <form id="arg-form" onSubmit={handleSubmit}>
       <label
         className={
-          'relative flex items-center mx-4 my-4 ' +
+          'relative flex flex-col mx-4 my-4 ' +
           (!hasSubmitted || canSubmitSelection || 'text-destroy-50')
         }
       >
@@ -100,13 +100,18 @@ function CommandBarSelectionInput({
           : `Please select ${
               arg.multiple ? 'one or more ' : 'one '
             }${getSemanticSelectionType(arg.selectionTypes).join(' or ')}`}
+        {arg.warningMessage && (
+          <p className="text-warn-80 bg-warn-10 px-2 py-1 rounded-sm mt-3 mr-2 -mb-2 w-full text-sm cursor-default">
+            {arg.warningMessage}
+          </p>
+        )}
         <input
           id="selection"
           name="selection"
           ref={inputRef}
           required
           placeholder="Select an entity with your mouse"
-          className="absolute inset-0 w-full h-full opacity-0 cursor-pointer"
+          className="absolute inset-0 w-full h-full opacity-0 cursor-default"
           onKeyDown={(event) => {
             if (event.key === 'Backspace') {
               stepBack()

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

@@ -2,7 +2,7 @@ import type { IndexLoaderData } from 'lib/types'
 import { PATHS } from 'lib/paths'
 import { ActionButton } from './ActionButton'
 import Tooltip from './Tooltip'
-import { Dispatch, useCallback, useEffect, useRef, useState } from 'react'
+import { Dispatch, useCallback, useRef, useState } from 'react'
 import { useNavigate, useRouteLoaderData } from 'react-router-dom'
 import { Disclosure } from '@headlessui/react'
 import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
@@ -13,7 +13,6 @@ import { sortProject } from 'lib/desktopFS'
 import { FILE_EXT } from 'lib/constants'
 import { CustomIcon } from './CustomIcon'
 import { codeManager, kclManager } from 'lib/singletons'
-import { useDocumentHasFocus } from 'hooks/useDocumentHasFocus'
 import { useLspContext } from './LspProvider'
 import useHotkeyWrapper from 'lib/hotkeyWrapper'
 import { useModelingContext } from 'hooks/useModelingContext'
@@ -21,6 +20,8 @@ import { DeleteConfirmationDialog } from './ProjectCard/DeleteProjectDialog'
 import { ContextMenu, ContextMenuItem } from './ContextMenu'
 import usePlatform from 'hooks/usePlatform'
 import { FileEntry } from 'lib/project'
+import { useFileSystemWatcher } from 'hooks/useFileSystemWatcher'
+import { normalizeLineEndings } from 'lib/codeEditor'
 
 function getIndentationCSS(level: number) {
   return `calc(1rem * ${level + 1})`
@@ -131,6 +132,30 @@ const FileTreeItem = ({
   const isCurrentFile = fileOrDir.path === currentFile?.path
   const itemRef = useRef(null)
 
+  // Since every file or directory gets its own FileTreeItem, we can do this.
+  // Because subtrees only render when they are opened, that means this
+  // only listens when they open. Because this acts like a useEffect, when
+  // the ReactNodes are destroyed, so is this listener :)
+  useFileSystemWatcher(
+    async (eventType, path) => {
+      // Don't try to read a file that was removed.
+      if (isCurrentFile && eventType !== 'unlink') {
+        // Prevents a cyclic read / write causing editor problems such as
+        // misplaced cursor positions.
+        if (codeManager.writeCausedByAppCheckedInFileTreeFileSystemWatcher) {
+          codeManager.writeCausedByAppCheckedInFileTreeFileSystemWatcher = false
+          return
+        }
+
+        let code = await window.electron.readFile(path, { encoding: 'utf-8' })
+        code = normalizeLineEndings(code)
+        codeManager.updateCodeStateEditor(code)
+      }
+      fileSend({ type: 'Refresh' })
+    },
+    [fileOrDir.path]
+  )
+
   const isRenaming = fileContext.itemsBeingRenamed.includes(fileOrDir.path)
   const removeCurrentItemFromRenaming = useCallback(
     () =>
@@ -154,6 +179,13 @@ const FileTreeItem = ({
     })
   }, [fileContext.itemsBeingRenamed, fileOrDir.path, fileSend])
 
+  const clickDirectory = () => {
+    fileSend({
+      type: 'Set selected directory',
+      directory: fileOrDir,
+    })
+  }
+
   function handleKeyUp(e: React.KeyboardEvent<HTMLButtonElement>) {
     if (e.metaKey && e.key === 'Backspace') {
       // Open confirmation dialog
@@ -242,18 +274,8 @@ const FileTreeItem = ({
                   }
                   style={{ paddingInlineStart: getIndentationCSS(level) }}
                   onClick={(e) => e.currentTarget.focus()}
-                  onClickCapture={(e) =>
-                    fileSend({
-                      type: 'Set selected directory',
-                      directory: fileOrDir,
-                    })
-                  }
-                  onFocusCapture={(e) =>
-                    fileSend({
-                      type: 'Set selected directory',
-                      directory: fileOrDir,
-                    })
-                  }
+                  onClickCapture={clickDirectory}
+                  onFocusCapture={clickDirectory}
                   onKeyDown={(e) => e.key === 'Enter' && e.preventDefault()}
                   onKeyUp={handleKeyUp}
                 >
@@ -469,27 +491,36 @@ export const FileTreeInner = ({
   const loaderData = useRouteLoaderData(PATHS.FILE) as IndexLoaderData
   const { send: fileSend, context: fileContext } = useFileContext()
   const { send: modelingSend } = useModelingContext()
-  const documentHasFocus = useDocumentHasFocus()
 
-  // Refresh the file tree when the document gets focus
-  useEffect(() => {
-    fileSend({ type: 'Refresh' })
-  }, [documentHasFocus])
+  // Refresh the file tree when there are changes.
+  useFileSystemWatcher(
+    async (eventType, path) => {
+      // Our other watcher races with this watcher on the current file changes,
+      // so we need to stop this one from reacting at all, otherwise Bad Things
+      // Happen™.
+      const isCurrentFile = loaderData.file?.path === path
+      const hasChanged = eventType === 'change'
+      if (isCurrentFile && hasChanged) return
+      fileSend({ type: 'Refresh' })
+    },
+    [loaderData?.project?.path, fileContext.selectedDirectory.path].filter(
+      (x: string | undefined) => x !== undefined
+    )
+  )
+
+  const clickDirectory = () => {
+    fileSend({
+      type: 'Set selected directory',
+      directory: fileContext.project,
+    })
+  }
 
   return (
     <div
       className="overflow-auto pb-12 absolute inset-0"
       data-testid="file-pane-scroll-container"
     >
-      <ul
-        className="m-0 p-0 text-sm"
-        onClickCapture={(e) => {
-          fileSend({
-            type: 'Set selected directory',
-            directory: fileContext.project,
-          })
-        }}
-      >
+      <ul className="m-0 p-0 text-sm" onClickCapture={clickDirectory}>
         {sortProject(fileContext.project?.children || []).map((fileOrDir) => (
           <FileTreeItem
             project={fileContext.project}

src/components/Gizmo.tsx

@@ -28,6 +28,7 @@ import {
 import { Popover } from '@headlessui/react'
 import { CustomIcon } from './CustomIcon'
 import { reportRejection } from 'lib/trap'
+import { useModelingContext } from 'hooks/useModelingContext'
 
 const CANVAS_SIZE = 80
 const FRUSTUM_SIZE = 0.5
@@ -62,6 +63,7 @@ export default function Gizmo() {
   const raycasterIntersect = useRef<Intersection<Object3D> | null>(null)
   const cameraPassiveUpdateTimer = useRef(0)
   const raycasterPassiveUpdateTimer = useRef(0)
+  const { send: modelingSend } = useModelingContext()
   const menuItems = useMemo(
     () => [
       ...Object.entries(axisNamesSemantic).map(([axisName, axisSemantic]) => (
@@ -76,6 +78,7 @@ export default function Gizmo() {
           {axisSemantic} view
         </ContextMenuItem>
       )),
+      <ContextMenuDivider />,
       <ContextMenuItem
         onClick={() => {
           sceneInfra.camControls.resetCameraPosition().catch(reportRejection)
@@ -83,6 +86,13 @@ export default function Gizmo() {
       >
         Reset view
       </ContextMenuItem>,
+      <ContextMenuItem
+        onClick={() => {
+          modelingSend({ type: 'Center camera on selection' })
+        }}
+      >
+        Center view on selection
+      </ContextMenuItem>,
       <ContextMenuDivider />,
       <ContextMenuItemRefresh />,
     ],

src/components/LowerRightControls.tsx

@@ -23,6 +23,7 @@ export function LowerRightControls({
 }) {
   const location = useLocation()
   const filePath = useAbsoluteFilePath()
+
   const linkOverrideClassName =
     '!text-chalkboard-70 hover:!text-chalkboard-80 dark:!text-chalkboard-40 dark:hover:!text-chalkboard-30'
 

src/components/MachineManagerProvider.tsx

@@ -0,0 +1,123 @@
+import { createContext, useEffect, useState } from 'react'
+
+import { engineCommandManager } from 'lib/singletons'
+import { CommandsContext } from 'components/CommandBar/CommandBarProvider'
+import { isDesktop } from 'lib/isDesktop'
+import { components } from 'lib/machine-api'
+import { reportRejection } from 'lib/trap'
+import { toSync } from 'lib/utils'
+
+export type MachinesListing = Array<
+  components['schemas']['MachineInfoResponse']
+>
+
+export interface MachineManager {
+  machines: MachinesListing
+  machineApiIp: string | null
+  currentMachine: components['schemas']['MachineInfoResponse'] | null
+  noMachinesReason: () => string | undefined
+  setCurrentMachine: (
+    m: components['schemas']['MachineInfoResponse'] | null
+  ) => void
+}
+
+export const MachineManagerContext = createContext<MachineManager>({
+  machines: [],
+  machineApiIp: null,
+  currentMachine: null,
+  setCurrentMachine: (
+    _: components['schemas']['MachineInfoResponse'] | null
+  ) => {},
+  noMachinesReason: () => undefined,
+})
+
+export const MachineManagerProvider = ({
+  children,
+}: {
+  children: React.ReactNode
+}) => {
+  const [machines, setMachines] = useState<MachinesListing>([])
+  const [machineApiIp, setMachineApiIp] = useState<string | null>(null)
+  const [currentMachine, setCurrentMachine] = useState<
+    components['schemas']['MachineInfoResponse'] | null
+  >(null)
+
+  const commandBarActor = CommandsContext.useActorRef()
+
+  // Get the reason message for why there are no machines.
+  const noMachinesReason = (): string | undefined => {
+    if (machines.length > 0) {
+      return undefined
+    }
+
+    if (machineApiIp === null) {
+      return 'Machine API server was not discovered'
+    }
+
+    return 'Machine API server was discovered, but no machines are available'
+  }
+
+  useEffect(() => {
+    if (!isDesktop()) return
+
+    const update = async () => {
+      const _machineApiIp = await window.electron.getMachineApiIp()
+      if (_machineApiIp === null) return
+
+      setMachineApiIp(_machineApiIp)
+
+      const _machines = await window.electron.listMachines(_machineApiIp)
+      setMachines(_machines)
+    }
+
+    // Start a background job to update the machines every ten seconds.
+    // If MDNS is already watching, this timeout will wait until it's done to trigger the
+    // finding again.
+    let timeoutId: ReturnType<typeof setTimeout> | undefined = undefined
+    const timeoutLoop = () => {
+      clearTimeout(timeoutId)
+      timeoutId = setTimeout(
+        toSync(async () => {
+          await update()
+          timeoutLoop()
+        }, reportRejection),
+        1000
+      )
+    }
+    timeoutLoop()
+    update().catch(reportRejection)
+  }, [])
+
+  // Update engineCommandManager's copy of this data.
+  useEffect(() => {
+    const machineManagerNext = {
+      machines,
+      machineApiIp,
+      currentMachine,
+      noMachinesReason,
+      setCurrentMachine,
+    }
+
+    engineCommandManager.machineManager = machineManagerNext
+
+    commandBarActor.send({
+      type: 'Set machine manager',
+      data: machineManagerNext,
+    })
+  }, [machines, machineApiIp, currentMachine])
+
+  return (
+    <MachineManagerContext.Provider
+      value={{
+        machines,
+        machineApiIp,
+        currentMachine,
+        setCurrentMachine,
+        noMachinesReason,
+      }}
+    >
+      {' '}
+      {children}{' '}
+    </MachineManagerContext.Provider>
+  )
+}

src/components/ModelingMachineProvider.tsx

@@ -1,5 +1,11 @@
 import { useMachine } from '@xstate/react'
-import React, { createContext, useEffect, useMemo, useRef } from 'react'
+import React, {
+  createContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useContext,
+} from 'react'
 import {
   Actor,
   AnyStateMachine,
@@ -28,7 +34,7 @@ import {
   editorManager,
   sceneEntitiesManager,
 } from 'lib/singletons'
-import { machineManager } from 'lib/machineManager'
+import { MachineManagerContext } from 'components/MachineManagerProvider'
 import { useHotkeys } from 'react-hotkeys-hook'
 import { applyConstraintHorzVertDistance } from './Toolbar/SetHorzVertDistance'
 import {
@@ -69,7 +75,7 @@ import { exportFromEngine } from 'lib/exportFromEngine'
 import { Models } from '@kittycad/lib/dist/types/src'
 import toast from 'react-hot-toast'
 import { EditorSelection, Transaction } from '@codemirror/state'
-import { useNavigate, useSearchParams } from 'react-router-dom'
+import { useLoaderData, useNavigate, useSearchParams } from 'react-router-dom'
 import { letEngineAnimateAndSyncCamAfter } from 'clientSideScene/CameraControls'
 import { getVarNameModal } from 'hooks/useToolbarGuards'
 import { err, reportRejection, trap } from 'lib/trap'
@@ -83,6 +89,8 @@ import {
 } from 'lang/std/engineConnection'
 import { submitAndAwaitTextToKcl } from 'lib/textToCad'
 import { useFileContext } from 'hooks/useFileContext'
+import { uuidv4 } from 'lib/utils'
+import { IndexLoaderData } from 'lib/types'
 
 type MachineContext<T extends AnyStateMachine> = {
   state: StateFrom<T>
@@ -115,6 +123,7 @@ export const ModelingMachineProvider = ({
   } = useSettingsAuthContext()
   const navigate = useNavigate()
   const { context, send: fileMachineSend } = useFileContext()
+  const { file } = useLoaderData() as IndexLoaderData
   const token = auth?.context?.token
   const streamRef = useRef<HTMLDivElement>(null)
   const persistedContext = useMemo(() => getPersistedContext(), [])
@@ -137,6 +146,8 @@ export const ModelingMachineProvider = ({
   //   >
   // )
 
+  const machineManager = useContext(MachineManagerContext)
+
   const [modelingState, modelingSend, modelingActor] = useMachine(
     modelingMachine.provide({
       actions: {
@@ -148,6 +159,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') {
@@ -243,6 +261,17 @@ export const ModelingMachineProvider = ({
             return {}
           },
         }),
+        'Center camera on selection': () => {
+          engineCommandManager
+            .sendSceneCommand({
+              type: 'modeling_cmd_req',
+              cmd_id: uuidv4(),
+              cmd: {
+                type: 'default_camera_center_to_selection',
+              },
+            })
+            .catch(reportRejection)
+        },
         'Set sketchDetails': assign(({ context: { sketchDetails }, event }) => {
           if (event.type !== 'Delete segment') return {}
           if (!sketchDetails) return {}
@@ -387,18 +416,35 @@ export const ModelingMachineProvider = ({
             return {}
           }
         ),
-        Make: ({ event }) => {
+        Make: ({ context, event }) => {
           if (event.type !== 'Make') return
           // Check if we already have an export intent.
-          if (engineCommandManager.exportIntent) {
+          if (engineCommandManager.exportInfo) {
             toast.error('Already exporting')
             return
           }
           // Set the export intent.
-          engineCommandManager.exportIntent = ExportIntent.Make
+          engineCommandManager.exportInfo = {
+            intent: ExportIntent.Make,
+            name: file?.name || '',
+          }
 
           // Set the current machine.
-          machineManager.currentMachine = event.data.machine
+          // Due to our use of singeton pattern, we need to do this to reliably
+          // update this object across React and non-React boundary.
+          // We need to do this eagerly because of the exportToEngine call below.
+          if (engineCommandManager.machineManager === null) {
+            console.warn(
+              "engineCommandManager.machineManager is null. It shouldn't be at this point. Aborting operation."
+            )
+            return
+          } else {
+            engineCommandManager.machineManager.currentMachine =
+              event.data.machine
+          }
+
+          // Update the rest of the UI that needs to know the current machine
+          context.machineManager.setCurrentMachine(event.data.machine)
 
           const format: Models['OutputFormat_type'] = {
             type: 'stl',
@@ -424,12 +470,16 @@ export const ModelingMachineProvider = ({
         },
         'Engine export': ({ event }) => {
           if (event.type !== 'Export') return
-          if (engineCommandManager.exportIntent) {
+          if (engineCommandManager.exportInfo) {
             toast.error('Already exporting')
             return
           }
           // Set the export intent.
-          engineCommandManager.exportIntent = ExportIntent.Save
+          engineCommandManager.exportInfo = {
+            intent: ExportIntent.Save,
+            // This never gets used its only for make.
+            name: '',
+          }
 
           const format = {
             ...event.data,
@@ -616,6 +666,7 @@ export const ModelingMachineProvider = ({
             input.plane
           )
           await kclManager.updateAst(modifiedAst, false)
+          sceneInfra.camControls.enableRotate = false
           sceneInfra.camControls.syncDirection = 'clientToEngine'
 
           await letEngineAnimateAndSyncCamAfter(
@@ -966,6 +1017,7 @@ export const ModelingMachineProvider = ({
           ...modelingMachineDefaultContext.store,
           ...persistedContext,
         },
+        machineManager,
       },
       // devTools: true,
     }
@@ -1037,6 +1089,11 @@ export const ModelingMachineProvider = ({
     modelingSend({ type: 'Delete selection' })
   })
 
+  // Allow ctrl+alt+c to center to selection
+  useHotkeys(['mod + alt + c'], () => {
+    modelingSend({ type: 'Center camera on selection' })
+  })
+
   useStateMachineCommands({
     machineId: 'modeling',
     state: modelingState,

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/ModelingSidebar/ModelingPanes/MemoryPane.tsx

@@ -95,7 +95,7 @@ export const processMemory = (programMemory: ProgramMemory) => {
           return rest
         })
       } else if (!err(sg)) {
-        processedMemory[key] = sg.value.map(({ __geoMeta, ...rest }: Path) => {
+        processedMemory[key] = sg.paths.map(({ __geoMeta, ...rest }: Path) => {
           return rest
         })
       } else if ((val.type as any) === 'Function') {

src/components/ModelingSidebar/ModelingSidebar.tsx

@@ -1,6 +1,12 @@
 import { useSettingsAuthContext } from 'hooks/useSettingsAuthContext'
 import { Resizable } from 're-resizable'
-import { MouseEventHandler, useCallback, useEffect, useMemo } from 'react'
+import {
+  MouseEventHandler,
+  useCallback,
+  useEffect,
+  useMemo,
+  useContext,
+} from 'react'
 import { useHotkeys } from 'react-hotkeys-hook'
 import { SidebarAction, SidebarType, sidebarPanes } from './ModelingPanes'
 import Tooltip from 'components/Tooltip'
@@ -13,7 +19,7 @@ import { CustomIconName } from 'components/CustomIcon'
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { IconDefinition } from '@fortawesome/free-solid-svg-icons'
 import { useKclContext } from 'lang/KclProvider'
-import { machineManager } from 'lib/machineManager'
+import { MachineManagerContext } from 'components/MachineManagerProvider'
 
 interface ModelingSidebarProps {
   paneOpacity: '' | 'opacity-20' | 'opacity-40'
@@ -29,6 +35,7 @@ function getPlatformString(): 'web' | 'desktop' {
 }
 
 export function ModelingSidebar({ paneOpacity }: ModelingSidebarProps) {
+  const machineManager = useContext(MachineManagerContext)
   const { commandBarSend } = useCommandsContext()
   const kclContext = useKclContext()
   const { settings } = useSettingsAuthContext()

src/components/NetworkMachineIndicator.tsx

@@ -1,7 +1,9 @@
 import { Popover } from '@headlessui/react'
+import { useContext } from 'react'
 import Tooltip from './Tooltip'
-import { machineManager } from 'lib/machineManager'
 import { isDesktop } from 'lib/isDesktop'
+import { components } from 'lib/machine-api'
+import { MachineManagerContext } from 'components/MachineManagerProvider'
 import { CustomIcon } from './CustomIcon'
 
 export const NetworkMachineIndicator = ({
@@ -9,8 +11,12 @@ export const NetworkMachineIndicator = ({
 }: {
   className?: string
 }) => {
-  const machineCount = machineManager.machineCount()
-  const reason = machineManager.noMachinesReason()
+  const {
+    noMachinesReason,
+    machines,
+    machines: { length: machineCount },
+  } = useContext(MachineManagerContext)
+  const reason = noMachinesReason()
 
   return isDesktop() ? (
     <Popover className="relative">
@@ -46,19 +52,35 @@ export const NetworkMachineIndicator = ({
         </div>
         {machineCount > 0 && (
           <ul className="divide-y divide-chalkboard-20 dark:divide-chalkboard-80">
-            {Object.entries(machineManager.machines).map(
-              ([hostname, machine]) => (
-                <li key={hostname} className={'px-2 py-4 gap-1 last:mb-0 '}>
-                  <p className="">
-                    {machine.make_model.model ||
-                      machine.make_model.manufacturer ||
-                      'Unknown Machine'}
-                  </p>
-                  <p className="text-chalkboard-60 dark:text-chalkboard-50 text-xs">
-                    Hostname {hostname}
-                  </p>
-                </li>
-              )
+            {machines.map(
+              (machine: components['schemas']['MachineInfoResponse']) => {
+                return (
+                  <li key={machine.id} className={'px-2 py-4 gap-1 last:mb-0 '}>
+                    <p className="">{machine.id.toUpperCase()}</p>
+                    <p className="text-chalkboard-60 dark:text-chalkboard-50 text-xs">
+                      {machine.make_model.model}
+                    </p>
+                    {machine.extra &&
+                      machine.extra.type === 'bambu' &&
+                      machine.extra.nozzle_diameter && (
+                        <p className="text-chalkboard-60 dark:text-chalkboard-50 text-xs">
+                          Nozzle Diameter: {machine.extra.nozzle_diameter}
+                        </p>
+                      )}
+                    <p className="text-chalkboard-60 dark:text-chalkboard-50 text-xs">
+                      {`Status: ${machine.state.state
+                        .charAt(0)
+                        .toUpperCase()}${machine.state.state.slice(1)}`}
+                      {machine.state.state === 'failed' && machine.state.message
+                        ? ` (${machine.state.message})`
+                        : ''}
+                      {machine.state.state === 'running' && machine.progress
+                        ? ` (${Math.round(machine.progress)}%)`
+                        : ''}
+                    </p>
+                  </li>
+                )
+              }
             )}
           </ul>
         )}

src/components/ProjectSidebarMenu.tsx

@@ -4,14 +4,14 @@ import { type IndexLoaderData } from 'lib/types'
 import { PATHS } from 'lib/paths'
 import { isDesktop } from '../lib/isDesktop'
 import { Link, useLocation, useNavigate } from 'react-router-dom'
-import { Fragment, useMemo } from 'react'
+import { Fragment, useMemo, useContext } from 'react'
 import { Logo } from './Logo'
 import { APP_NAME } from 'lib/constants'
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { CustomIcon } from './CustomIcon'
 import { useLspContext } from './LspProvider'
 import { engineCommandManager } from 'lib/singletons'
-import { machineManager } from 'lib/machineManager'
+import { MachineManagerContext } from 'components/MachineManagerProvider'
 import usePlatform from 'hooks/usePlatform'
 import { useAbsoluteFilePath } from 'hooks/useAbsoluteFilePath'
 import Tooltip from './Tooltip'
@@ -96,6 +96,8 @@ function ProjectMenuPopover({
   const location = useLocation()
   const navigate = useNavigate()
   const filePath = useAbsoluteFilePath()
+  const machineManager = useContext(MachineManagerContext)
+
   const { commandBarState, commandBarSend } = useCommandsContext()
   const { onProjectClose } = useLspContext()
   const exportCommandInfo = { name: 'Export', groupId: 'modeling' }
@@ -106,7 +108,7 @@ function ProjectMenuPopover({
         (c) => c.name === obj.name && c.groupId === obj.groupId
       )
     )
-  const machineCount = machineManager.machineCount()
+  const machineCount = machineManager.machines.length
 
   // We filter this memoized list so that no orphan "break" elements are rendered.
   const projectMenuItems = useMemo<(ActionButtonProps | 'break')[]>(

src/components/SettingsAuthProvider.tsx

@@ -1,9 +1,10 @@
+import { trap } from 'lib/trap'
 import { useMachine } from '@xstate/react'
 import { useNavigate, useRouteLoaderData, useLocation } from 'react-router-dom'
 import { PATHS } from 'lib/paths'
 import { authMachine, TOKEN_PERSIST_KEY } from '../machines/authMachine'
 import withBaseUrl from '../lib/withBaseURL'
-import React, { createContext, useEffect } from 'react'
+import React, { createContext, useEffect, useState } from 'react'
 import useStateMachineCommands from '../hooks/useStateMachineCommands'
 import { settingsMachine } from 'machines/settingsMachine'
 import { toast } from 'react-hot-toast'
@@ -15,7 +16,6 @@ import {
 } from 'lib/theme'
 import decamelize from 'decamelize'
 import { Actor, AnyStateMachine, ContextFrom, Prop, StateFrom } from 'xstate'
-import { isDesktop } from 'lib/isDesktop'
 import { authCommandBarConfig } from 'lib/commandBarConfigs/authCommandConfig'
 import {
   kclManager,
@@ -33,8 +33,14 @@ import {
 import { useCommandsContext } from 'hooks/useCommandsContext'
 import { Command } from 'lib/commandTypes'
 import { BaseUnit } from 'lib/settings/settingsTypes'
-import { saveSettings } from 'lib/settings/settingsUtils'
+import {
+  saveSettings,
+  loadAndValidateSettings,
+} from 'lib/settings/settingsUtils'
 import { reportRejection } from 'lib/trap'
+import { getAppSettingsFilePath } from 'lib/desktop'
+import { isDesktop } from 'lib/isDesktop'
+import { useFileSystemWatcher } from 'hooks/useFileSystemWatcher'
 
 type MachineContext<T extends AnyStateMachine> = {
   state: StateFrom<T>
@@ -99,6 +105,9 @@ export const SettingsAuthProviderBase = ({
   const location = useLocation()
   const navigate = useNavigate()
   const { commandBarSend } = useCommandsContext()
+  const [settingsPath, setSettingsPath] = useState<string | undefined>(
+    undefined
+  )
 
   const [settingsState, settingsSend, settingsActor] = useMachine(
     settingsMachine.provide({
@@ -191,7 +200,11 @@ export const SettingsAuthProviderBase = ({
             console.error('Error executing AST after settings change', e)
           }
         },
-        persistSettings: ({ context }) => {
+        persistSettings: ({ context, event }) => {
+          // Without this, when a user changes the file, it'd
+          // create a detection loop with the file-system watcher.
+          if (event.doNotPersist) return
+
           // eslint-disable-next-line @typescript-eslint/no-floating-promises
           saveSettings(context, loadedProject?.project?.path)
         },
@@ -201,6 +214,38 @@ export const SettingsAuthProviderBase = ({
   )
   settingsStateRef = settingsState.context
 
+  useEffect(() => {
+    if (!isDesktop()) return
+    getAppSettingsFilePath().then(setSettingsPath).catch(trap)
+  }, [])
+
+  useFileSystemWatcher(
+    async () => {
+      // If there is a projectPath but it no longer exists it means
+      // it was exterally removed. If we let the code past this condition
+      // execute it will recreate the directory due to code in
+      // loadAndValidateSettings trying to recreate files. I do not
+      // wish to change the behavior in case anything else uses it.
+      // Go home.
+      if (loadedProject?.project?.path) {
+        if (!window.electron.exists(loadedProject?.project?.path)) {
+          navigate(PATHS.HOME)
+          return
+        }
+      }
+
+      const data = await loadAndValidateSettings(loadedProject?.project?.path)
+      settingsSend({
+        type: 'Set all settings',
+        settings: data.settings,
+        doNotPersist: true,
+      })
+    },
+    [settingsPath, loadedProject?.project?.path].filter(
+      (x: string | undefined) => x !== undefined
+    )
+  )
+
   // Add settings commands to the command bar
   // They're treated slightly differently than other commands
   // Because their state machine doesn't have a meaningful .nextEvents,

src/components/Stream.tsx

@@ -255,10 +255,14 @@ export const Stream = () => {
   }, [mediaStream])
 
   const handleMouseUp: MouseEventHandler<HTMLDivElement> = (e) => {
+    // If we've got no stream or connection, don't do anything
     if (!isNetworkOkay) return
     if (!videoRef.current) return
+    // If we're in sketch mode, don't send a engine-side select event
     if (state.matches('Sketch')) return
     if (state.matches({ idle: 'showPlanes' })) return
+    // If we're mousing up from a camera drag, don't send a select event
+    if (sceneInfra.camControls.wasDragging === true) return
 
     if (btnName(e.nativeEvent).left) {
       // eslint-disable-next-line @typescript-eslint/no-floating-promises

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,
@@ -8,7 +11,7 @@ export const kclHighlight = styleTags({
   nil: t.null,
   'AddOp MultOp ExpOp': t.arithmeticOperator,
   BangOp: t.logicOperator,
-  CompOp: t.logicOperator,
+  CompOp: t.compareOperator,
   'Equals Arrow': t.definitionOperator,
   PipeOperator: t.controlOperator,
   String: t.string,

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] { "'" ("\\" _ | !['\\])* "'" | '"' ("\\" _ | !["\\])* '"' }
 
@@ -84,7 +90,7 @@ commaSep<term> { (term ("," term)*)? ","? }
   MultOp { "/" | "*" | "\\" }
   ExpOp { "^" }
   BangOp { "!" }
-  CompOp { $[<>] "="? | "!=" | "==" }
+  CompOp { "==" | "!=" | "<=" | ">=" | "<" | ">" }
   Equals { "=" }
   Arrow { "=>" }
   PipeOperator { "|>" }
@@ -106,6 +112,9 @@ commaSep<term> { (term ("," term)*)? ","? }
 
   Shebang { "#!" ![\n]* }
 
+  ImportItemAs { "as" }
+  ImportFrom { "from" }
+
   "(" ")"
   "{" "}"
   "[" "]"

src/hooks/useFileSystemWatcher.tsx

@@ -1,4 +1,5 @@
 import { isDesktop } from 'lib/isDesktop'
+import { reportRejection } from 'lib/trap'
 import { useEffect, useState, useRef } from 'react'
 
 type Path = string
@@ -11,33 +12,51 @@ type Path = string
 // watcher.addListener(() => { ... }).
 
 export const useFileSystemWatcher = (
-  callback: (path: Path) => void,
-  dependencyArray: Path[]
+  callback: (eventType: string, path: Path) => Promise<void>,
+  paths: Path[]
 ): void => {
-  // Track a ref to the callback. This is how we get the callback updated
-  // across the NodeJS<->Browser boundary.
-  const callbackRef = useRef<{ fn: (path: Path) => void }>({
-    fn: (_path) => {},
-  })
+  // Used to track this instance of useFileSystemWatcher.
+  // Assign to ref so it doesn't change between renders.
+  const key = useRef(Math.random().toString())
+
+  const [output, setOutput] = useState<
+    { eventType: string; path: string } | undefined
+  >(undefined)
+
+  // Used to track if paths list changes.
+  const [pathsTracked, setPathsTracked] = useState<Path[]>([])
 
   useEffect(() => {
-    callbackRef.current.fn = callback
-  }, [callback])
-
-  // Used to track if dependencyArrray changes.
-  const [dependencyArrayTracked, setDependencyArrayTracked] = useState<Path[]>(
-    []
-  )
+    if (!output) return
+    callback(output.eventType, output.path).catch(reportRejection)
+  }, [output])
 
   // On component teardown obliterate all watchers.
   useEffect(() => {
     // The hook is useless on web.
     if (!isDesktop()) return
 
-    return () => {
-      window.electron.watchFileObliterate()
+    const cbWatcher = (eventType: string, path: string) => {
+      setOutput({ eventType, path })
     }
-  }, [])
+
+    for (let path of pathsTracked) {
+      // Because functions don't retain refs between NodeJS-Browser I need to
+      // pass an identifying key so we can later remove it.
+      // A way to think of the function call is:
+      // "For this path, add a new handler with this key"
+      // "There can be many keys (functions) per path"
+      // Again if refs were preserved, we wouldn't need to do this. Keys
+      // gives us uniqueness.
+      window.electron.watchFileOn(path, key.current, cbWatcher)
+    }
+
+    return () => {
+      for (let path of pathsTracked) {
+        window.electron.watchFileOff(path, key.current)
+      }
+    }
+  }, [pathsTracked])
 
   function difference<T>(l1: T[], l2: T[]): [T[], T[]] {
     return [
@@ -46,6 +65,8 @@ export const useFileSystemWatcher = (
     ]
   }
 
+  const hasDiff = difference(paths, pathsTracked)[0].length !== 0
+
   // Removing 1 watcher at a time is only possible because in a filesystem,
   // a path is unique (there can never be two paths with the same name).
   // Otherwise we would have to obliterate() the whole list and reconstruct it.
@@ -53,19 +74,10 @@ export const useFileSystemWatcher = (
     // The hook is useless on web.
     if (!isDesktop()) return
 
-    const [pathsRemoved, pathsRemaining] = difference(
-      dependencyArrayTracked,
-      dependencyArray
-    )
-    for (let path of pathsRemoved) {
-      window.electron.watchFileOff(path)
-    }
-    const [pathsAdded] = difference(dependencyArray, dependencyArrayTracked)
-    for (let path of pathsAdded) {
-      window.electron.watchFileOn(path, (_eventType: string, path: Path) =>
-        callbackRef.current.fn(path)
-      )
-    }
-    setDependencyArrayTracked(pathsRemaining.concat(pathsAdded))
-  }, [difference(dependencyArray, dependencyArrayTracked)[0].length !== 0])
+    if (!hasDiff) return
+
+    const [, pathsRemaining] = difference(pathsTracked, paths)
+    const [pathsAdded] = difference(paths, pathsTracked)
+    setPathsTracked(pathsRemaining.concat(pathsAdded))
+  }, [hasDiff])
 }

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,
@@ -38,10 +40,9 @@ export class KclManager {
     nonCodeMeta: {
       nonCodeNodes: {},
       start: [],
-      digest: null,
     },
-    digest: null,
   }
+  private _execState: ExecState = emptyExecState()
   private _programMemory: ProgramMemory = ProgramMemory.empty()
   lastSuccessfulProgramMemory: ProgramMemory = ProgramMemory.empty()
   private _logs: string[] = []
@@ -72,11 +73,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
   }
@@ -195,9 +206,7 @@ export class KclManager {
       nonCodeMeta: {
         nonCodeNodes: {},
         start: [],
-        digest: null,
       },
-      digest: null,
     }
   }
 
@@ -253,8 +262,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 +274,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 = ''
@@ -282,6 +292,7 @@ export class KclManager {
             type: 'zoom_to_fit',
             object_ids: zoomObjectId ? [zoomObjectId] : [], // leave empty to zoom to all objects
             padding: 0.1, // padding around the objects
+            animated: false, // don't animate the zoom for now
           },
         })
       }
@@ -294,12 +305,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()
@@ -337,17 +356,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
 
@@ -552,6 +573,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] }],
@@ -32,7 +32,7 @@ const mySketch001 = startSketchOn('XY')
             sourceRange: [46, 71],
           },
         },
-        value: [
+        paths: [
           {
             type: 'ToPoint',
             tag: null,
@@ -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),
@@ -96,7 +96,7 @@ const mySketch001 = startSketchOn('XY')
         on: expect.any(Object),
         start: expect.any(Object),
         type: 'Sketch',
-        value: [
+        paths: [
           {
             type: 'ToPoint',
             from: [0, 0],
@@ -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',
@@ -171,7 +172,6 @@ const sk2 = startSketchOn('XY')
               start: 114,
               type: 'TagDeclarator',
               value: 'p',
-              digest: null,
             },
             id: expect.any(String),
             sourceRange: [95, 117],
@@ -202,7 +202,7 @@ const sk2 = startSketchOn('XY')
               info: expect.any(Object),
             },
           },
-          value: [
+          paths: [
             {
               type: 'ToPoint',
               from: [0, 0],
@@ -222,7 +222,6 @@ const sk2 = startSketchOn('XY')
                 start: 114,
                 type: 'TagDeclarator',
                 value: 'p',
-                digest: null,
               },
               __geoMeta: {
                 id: expect.any(String),
@@ -265,7 +264,6 @@ const sk2 = startSketchOn('XY')
               start: 417,
               type: 'TagDeclarator',
               value: 'o',
-              digest: null,
             },
             id: expect.any(String),
             sourceRange: [399, 420],
@@ -296,7 +294,7 @@ const sk2 = startSketchOn('XY')
               info: expect.any(Object),
             },
           },
-          value: [
+          paths: [
             {
               type: 'ToPoint',
               from: [0, 0],
@@ -316,7 +314,6 @@ const sk2 = startSketchOn('XY')
                 start: 417,
                 type: 'TagDeclarator',
                 value: 'o',
-                digest: null,
               },
               __geoMeta: {
                 id: expect.any(String),

src/lang/codeManager.ts

@@ -18,6 +18,9 @@ export default class CodeManager {
   #updateState: (arg: string) => void = () => {}
   private _currentFilePath: string | null = null
   private _hotkeys: { [key: string]: () => void } = {}
+  private timeoutWriter: ReturnType<typeof setTimeout> | undefined = undefined
+
+  public writeCausedByAppCheckedInFileTreeFileSystemWatcher = false
 
   constructor() {
     if (isDesktop()) {
@@ -115,7 +118,12 @@ export default class CodeManager {
 
   async writeToFile() {
     if (isDesktop()) {
-      setTimeout(() => {
+      // Only write our buffer contents to file once per second. Any faster
+      // and file-system watchers which read, will receive empty data during
+      // writes.
+      clearTimeout(this.timeoutWriter)
+      this.writeCausedByAppCheckedInFileTreeFileSystemWatcher = true
+      this.timeoutWriter = setTimeout(() => {
         // Wait one event loop to give a chance for params to be set
         // Save the file to disk
         this._currentFilePath &&
@@ -126,7 +134,7 @@ export default class CodeManager {
               console.error('error saving file', err)
               toast.error('Error saving file, please check file permissions')
             })
-      })
+      }, 1000)
     } else {
       safeLSSetItem(PERSIST_CODE_KEY, this.code)
     }

src/lang/executor.test.ts

@@ -58,7 +58,7 @@ const newVar = myVar + 1`
 `
     const mem = await exe(code)
     // geo is three js buffer geometry and is very bloated to have in tests
-    const minusGeo = mem.get('mySketch')?.value?.value
+    const minusGeo = mem.get('mySketch')?.value?.paths
     expect(minusGeo).toEqual([
       {
         type: 'ToPoint',
@@ -73,7 +73,6 @@ const newVar = myVar + 1`
           start: 89,
           type: 'TagDeclarator',
           value: 'myPath',
-          digest: null,
         },
       },
       {
@@ -99,7 +98,6 @@ const newVar = myVar + 1`
           start: 143,
           type: 'TagDeclarator',
           value: 'rightPath',
-          digest: null,
         },
       },
     ])
@@ -177,7 +175,7 @@ const newVar = myVar + 1`
             info: expect.any(Object),
           },
         },
-        value: [
+        paths: [
           {
             type: 'ToPoint',
             to: [1, 1],
@@ -201,7 +199,6 @@ const newVar = myVar + 1`
               start: 109,
               type: 'TagDeclarator',
               value: 'myPath',
-              digest: null,
             },
           },
           {
@@ -370,7 +367,7 @@ describe('testing math operators', () => {
     const mem = await exe(code)
     const sketch = sketchFromKclValue(mem.get('part001'), 'part001')
     // result of `-legLen(5, min(3, 999))` should be -4
-    const yVal = (sketch as Sketch).value?.[0]?.to?.[1]
+    const yVal = (sketch as Sketch).paths?.[0]?.to?.[1]
     expect(yVal).toBe(-4)
   })
   it('test that % substitution feeds down CallExp->ArrExp->UnaryExp->CallExp', async () => {
@@ -388,8 +385,8 @@ describe('testing math operators', () => {
     const mem = await exe(code)
     const sketch = sketchFromKclValue(mem.get('part001'), 'part001')
     // expect -legLen(segLen('seg01'), myVar) to equal -4 setting the y value back to 0
-    expect((sketch as Sketch).value?.[1]?.from).toEqual([3, 4])
-    expect((sketch as Sketch).value?.[1]?.to).toEqual([6, 0])
+    expect((sketch as Sketch).paths?.[1]?.from).toEqual([3, 4])
+    expect((sketch as Sketch).paths?.[1]?.to).toEqual([6, 0])
     const removedUnaryExp = code.replace(
       `-legLen(segLen(seg01), myVar)`,
       `legLen(segLen(seg01), myVar)`
@@ -401,7 +398,7 @@ describe('testing math operators', () => {
     )
 
     // without the minus sign, the y value should be 8
-    expect((removedUnaryExpMemSketch as Sketch).value?.[1]?.to).toEqual([6, 8])
+    expect((removedUnaryExpMemSketch as Sketch).paths?.[1]?.to).toEqual([6, 8])
   })
   it('with nested callExpression and binaryExpression', async () => {
     const code = 'const myVar = 2 + min(100, -1 + legLen(5, 3))'
@@ -443,6 +440,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
 }