Lint again

This reverts commit 53a04d0f24.

.github/workflows/e2e-tests.yml

@@ -75,7 +75,7 @@ jobs:
 
   prepare-wasm:
     # seperate job on Ubuntu to build or fetch the wasm blob once on the fastest runner
-    runs-on: namespace-profile-ubuntu-8-cores
+    runs-on: runs-on=${{ github.run_id }}/family=i7ie.2xlarge/image=ubuntu22-full-x64
     needs: conditions
     steps:
       - uses: actions/checkout@v4
@@ -163,7 +163,7 @@ jobs:
 
   snapshots:
     name: playwright:snapshots:ubuntu
-    runs-on: namespace-profile-ubuntu-8-cores
+    runs-on: runs-on=${{ github.run_id }}/family=i7ie.2xlarge/image=ubuntu22-full-x64
     needs: [conditions, prepare-wasm]
     steps:
       - uses: actions/create-github-app-token@v1
@@ -220,8 +220,12 @@ jobs:
 
       - name: Run ubuntu/chrome snapshots
         if: needs.conditions.outputs.should-run == 'true'
-        run: |
-          yarn test:snapshots
+        uses: nick-fields/retry@v3.0.2
+        with:
+          shell: bash
+          command: yarn test:snapshots
+          timeout_minutes: 30
+          max_attempts: 3
         env:
           CI: true
           NODE_ENV: development
@@ -233,19 +237,14 @@ jobs:
       - uses: actions/upload-artifact@v4
         if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
         with:
-          name: playwright-report-snapshots-${{ matrix.os }}-snapshot-${{ matrix.shardIndex }}-${{ github.sha }}
+          name: playwright-report-ubuntu-snapshot-${{ github.sha }}
           path: playwright-report/
           include-hidden-files: true
           retention-days: 30
           overwrite: true
 
-      - name: Clean up test-results
-        if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
-        continue-on-error: true
-        run: rm -r test-results
-
       - name: check for changes
-        if: ${{ needs.conditions.outputs.should-run == 'true' && matrix.os == 'namespace-profile-ubuntu-8-cores' && matrix.shardIndex == 1 && github.ref != 'refs/heads/main' }}
+        if: ${{ needs.conditions.outputs.should-run == 'true' && github.ref != 'refs/heads/main' }}
         shell: bash
         id: git-check
         run: |
@@ -266,31 +265,36 @@ jobs:
           git fetch origin
           echo ${{ github.head_ref }}
           git checkout ${{ github.head_ref }}
-          git commit -m "A snapshot a day keeps the bugs away! 📷🐛 (OS: ${{matrix.os}})" || true
+          git commit -m "A snapshot a day keeps the bugs away! 📷🐛" || true
           git push
           git push origin ${{ github.head_ref }}
 
-      # only upload artifacts if there's actually changes
-      - uses: actions/upload-artifact@v4
-        if: ${{ needs.conditions.outputs.should-run == 'true' && steps.git-check.outputs.modified == 'true' }}
-        with:
-          name: playwright-report-ubuntu-${{ github.sha }}
-          path: playwright-report/
-          include-hidden-files: true
-          retention-days: 30
-
-
   electron:
     needs: [conditions, prepare-wasm]
     timeout-minutes: 60
-    name: playwright:electron:${{ matrix.os }} ${{ matrix.shardIndex }} ${{ matrix.shardTotal }}
+    env:
+      OS_NAME: ${{ contains(matrix.os, 'ubuntu') && 'ubuntu' || (contains(matrix.os, 'windows') && 'windows' || 'macos') }}
+    name: playwright:electron:${{ contains(matrix.os, 'ubuntu') && 'ubuntu' || (contains(matrix.os, 'windows') && 'windows' || 'macos') }}:${{ matrix.shardIndex }}:${{ matrix.shardTotal }}
     strategy:
       fail-fast: false
       matrix:
-        # TODO: enable self-hosted-windows-8-cores once available
-        os: [namespace-profile-ubuntu-8-cores, namespace-profile-macos-8-cores, windows-16-cores]
+        # TODO: enable namespace-profile-windows-latest once available
+        os:
+          - "runs-on=${{ github.run_id }}/family=i7ie.2xlarge/image=ubuntu22-full-x64"
+          - namespace-profile-macos-8-cores
+          - windows-latest
         shardIndex: [1, 2, 3, 4]
         shardTotal: [4]
+        # Disable macos and windows tests on hourly e2e tests since we only care
+        # about server side changes.
+        # Technique from https://github.com/joaomcteixeira/python-project-skeleton/pull/31/files
+        isScheduled:
+          - ${{ github.event_name == 'schedule' }}
+        exclude:
+          - os: namespace-profile-macos-8-cores
+            isScheduled: true
+          - os: windows-latest
+            isScheduled: true
         # TODO: add ref here for main and latest release tag
     runs-on: ${{ matrix.os }}
     steps:
@@ -347,7 +351,7 @@ jobs:
         if: ${{ needs.conditions.outputs.should-run == 'true' && !cancelled() && (success() || failure()) }}
         continue-on-error: true
         with:
-          name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          name: test-results-${{ env.OS_NAME }}-${{ matrix.shardIndex }}-${{ github.sha }}
           path: test-results/
 
       - name: Run playwright/electron flow (with retries)
@@ -356,9 +360,9 @@ jobs:
         uses: nick-fields/retry@v3.0.2
         with:
           shell: bash
-          command: .github/ci-cd-scripts/playwright-electron.sh ${{matrix.shardIndex}} ${{matrix.shardTotal}} ${{matrix.os}}
-          timeout_minutes: 30
-          max_attempts: 25
+          command: .github/ci-cd-scripts/playwright-electron.sh ${{matrix.shardIndex}} ${{matrix.shardTotal}} ${{ env.OS_NAME }}
+          timeout_minutes: 45
+          max_attempts: 15
         env:
           CI: true
           FAIL_ON_CONSOLE_ERRORS: true
@@ -370,7 +374,7 @@ jobs:
       - uses: actions/upload-artifact@v4
         if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
         with:
-          name: test-results-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          name: test-results-${{ env.OS_NAME }}-${{ matrix.shardIndex }}-${{ github.sha }}
           path: test-results/
           include-hidden-files: true
           retention-days: 30
@@ -379,7 +383,7 @@ jobs:
       - uses: actions/upload-artifact@v4
         if: ${{ needs.conditions.outputs.should-run == 'true' && always() }}
         with:
-          name: playwright-report-${{ matrix.os }}-${{ matrix.shardIndex }}-${{ github.sha }}
+          name: playwright-report-${{ env.OS_NAME }}-${{ matrix.shardIndex }}-${{ github.sha }}
           path: playwright-report/
           include-hidden-files: true
           retention-days: 30

docs/kcl/appearance.md

@@ -10,11 +10,11 @@ This will work on any solid, including extruded solids, revolved solids, and she
 
 ```js
 appearance(
-  solidSet: SolidSet,
+  solids: [Solid],
   color: String,
   metalness?: number,
   roughness?: number,
-): SolidSet
+): [Solid]
 ```
 
 
@@ -22,14 +22,14 @@ appearance(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidSet`](/docs/kcl/types/SolidSet) | The solid(s) whose appearance is being set | Yes |
+| `solids` | [`[Solid]`](/docs/kcl/types/Solid) | The solid(s) whose appearance is being set | Yes |
 | `color` | `String` | Color of the new material, a hex string like '#ff0000' | Yes |
 | `metalness` | [`number`](/docs/kcl/types/number) | Metalness of the new material, a percentage like 95.7. | No |
 | `roughness` | [`number`](/docs/kcl/types/number) | Roughness of the new material, a percentage like 95.7. | No |
 
 ### Returns
 
-[`SolidSet`](/docs/kcl/types/SolidSet) - A solid or a group of solids.
+[`[Solid]`](/docs/kcl/types/Solid)
 
 
 ### Examples

docs/kcl/extrude.md

@@ -10,9 +10,9 @@ You can provide more than one sketch to extrude, and they will all be extruded i
 
 ```js
 extrude(
-  sketchSet: SketchSet,
+  sketches: [Sketch],
   length: number,
-): SolidSet
+): [Solid]
 ```
 
 
@@ -20,12 +20,12 @@ extrude(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | Which sketch or set of sketches should be extruded | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) | Which sketch or sketches should be extruded | Yes |
 | `length` | [`number`](/docs/kcl/types/number) | How far to extrude the given sketches | Yes |
 
 ### Returns
 
-[`SolidSet`](/docs/kcl/types/SolidSet) - A solid or a group of solids.
+[`[Solid]`](/docs/kcl/types/Solid)
 
 
 ### Examples

docs/kcl/hole.md

@@ -10,7 +10,7 @@ Use a 2-dimensional sketch to cut a hole in another 2-dimensional sketch.
 
 ```js
 hole(
-  holeSketch: SketchSet,
+  holeSketch: [Sketch],
   sketch: Sketch,
 ): Sketch
 ```
@@ -20,7 +20,7 @@ hole(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `holeSketch` | [`SketchSet`](/docs/kcl/types/SketchSet) | A sketch or a group of sketches. | Yes |
+| `holeSketch` | [`[Sketch]`](/docs/kcl/types/Sketch) |  | Yes |
 | `sketch` | [`Sketch`](/docs/kcl/types/Sketch) |  | Yes |
 
 ### Returns

docs/kcl/mirror2d.md

@@ -13,7 +13,7 @@ Mirror occurs around a local sketch axis rather than a global axis.
 ```js
 mirror2d(
   data: Mirror2dData,
-  sketchSet: SketchSet,
+  sketches: [Sketch],
 ): [Sketch]
 ```
 
@@ -23,7 +23,7 @@ mirror2d(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `data` | [`Mirror2dData`](/docs/kcl/types/Mirror2dData) | Data for a mirror. | Yes |
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | A sketch or a group of sketches. | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) |  | Yes |
 
 ### Returns
 

docs/kcl/patternCircular2d.md

@@ -10,7 +10,7 @@ Repeat a 2-dimensional sketch some number of times along a partial or complete c
 
 ```js
 patternCircular2d(
-  sketchSet: SketchSet,
+  sketchSet: [Sketch],
   instances: integer,
   center: [number],
   arcDegrees: number,
@@ -24,7 +24,7 @@ patternCircular2d(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | Which sketch(es) to pattern | Yes |
+| `sketchSet` | [`[Sketch]`](/docs/kcl/types/Sketch) | Which sketch(es) to pattern | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `center` | [`[number]`](/docs/kcl/types/number) | The center about which to make the pattern. This is a 2D vector. | Yes |
 | `arcDegrees` | [`number`](/docs/kcl/types/number) | The arc angle (in degrees) to place the repetitions. Must be greater than 0. | Yes |

docs/kcl/patternCircular3d.md

@@ -10,7 +10,7 @@ Repeat a 3-dimensional solid some number of times along a partial or complete ci
 
 ```js
 patternCircular3d(
-  solidSet: SolidSet,
+  solids: [Solid],
   instances: integer,
   axis: [number],
   center: [number],
@@ -25,7 +25,7 @@ patternCircular3d(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidSet`](/docs/kcl/types/SolidSet) | Which solid(s) to pattern | Yes |
+| `solids` | [`[Solid]`](/docs/kcl/types/Solid) | Which solid(s) to pattern | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `axis` | [`[number]`](/docs/kcl/types/number) | The axis around which to make the pattern. This is a 3D vector | Yes |
 | `center` | [`[number]`](/docs/kcl/types/number) | The center about which to make the pattern. This is a 3D vector. | Yes |

docs/kcl/patternLinear2d.md

@@ -10,7 +10,7 @@ Repeat a 2-dimensional sketch along some dimension, with a dynamic amount of dis
 
 ```js
 patternLinear2d(
-  sketchSet: SketchSet,
+  sketches: [Sketch],
   instances: integer,
   distance: number,
   axis: [number],
@@ -23,7 +23,7 @@ patternLinear2d(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | The sketch(es) to duplicate | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) | The sketch(es) to duplicate | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `distance` | [`number`](/docs/kcl/types/number) | Distance between each repetition. Also known as 'spacing'. | Yes |
 | `axis` | [`[number]`](/docs/kcl/types/number) | The axis of the pattern. A 2D vector. | Yes |

docs/kcl/patternLinear3d.md

@@ -10,7 +10,7 @@ Repeat a 3-dimensional solid along a linear path, with a dynamic amount of dista
 
 ```js
 patternLinear3d(
-  solidSet: SolidSet,
+  solids: [Solid],
   instances: integer,
   distance: number,
   axis: [number],
@@ -23,7 +23,7 @@ patternLinear3d(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidSet`](/docs/kcl/types/SolidSet) | The solid(s) to duplicate | Yes |
+| `solids` | [`[Solid]`](/docs/kcl/types/Solid) | The solid(s) to duplicate | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `distance` | [`number`](/docs/kcl/types/number) | Distance between each repetition. Also known as 'spacing'. | Yes |
 | `axis` | [`[number]`](/docs/kcl/types/number) | The axis of the pattern. A 2D vector. | Yes |

docs/kcl/patternTransform.md

@@ -36,7 +36,7 @@ The transform function returns a transform object. All properties of the object
 
 ```js
 patternTransform(
-  solidSet: SolidSet,
+  solids: [Solid],
   instances: integer,
   transform: FunctionSource,
   useOriginal?: bool,
@@ -48,7 +48,7 @@ patternTransform(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidSet`](/docs/kcl/types/SolidSet) | The solid(s) to duplicate | Yes |
+| `solids` | [`[Solid]`](/docs/kcl/types/Solid) | The solid(s) to duplicate | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `transform` | `FunctionSource` | How each replica should be transformed. The transform function takes a single parameter: an integer representing which number replication the transform is for. E.g. the first replica to be transformed will be passed the argument `1`. This simplifies your math: the transform function can rely on id `0` being the original instance passed into the `patternTransform`. See the examples. | Yes |
 | `useOriginal` | [`bool`](/docs/kcl/types/bool) | If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false. | No |

docs/kcl/patternTransform2d.md

@@ -10,7 +10,7 @@ Just like patternTransform, but works on 2D sketches not 3D solids.
 
 ```js
 patternTransform2d(
-  sketchSet: SketchSet,
+  sketches: [Sketch],
   instances: integer,
   transform: FunctionSource,
   useOriginal?: bool,
@@ -22,7 +22,7 @@ patternTransform2d(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | The sketch(es) to duplicate | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) | The sketch(es) to duplicate | Yes |
 | `instances` | `integer` | The number of total instances. Must be greater than or equal to 1. This includes the original entity. For example, if instances is 2, there will be two copies -- the original, and one new copy. If instances is 1, this has no effect. | Yes |
 | `transform` | `FunctionSource` | How each replica should be transformed. The transform function takes a single parameter: an integer representing which number replication the transform is for. E.g. the first replica to be transformed will be passed the argument `1`. This simplifies your math: the transform function can rely on id `0` being the original instance passed into the `patternTransform`. See the examples. | Yes |
 | `useOriginal` | [`bool`](/docs/kcl/types/bool) | If the target was sketched on an extrusion, setting this will use the original sketch as the target, not the entire joined solid. Defaults to false. | No |

docs/kcl/revolve.md

@@ -15,8 +15,8 @@ You can provide more than one sketch to revolve, and they will all be revolved a
 ```js
 revolve(
   data: RevolveData,
-  sketchSet: SketchSet,
-): SolidSet
+  sketches: [Sketch],
+): [Solid]
 ```
 
 
@@ -25,11 +25,11 @@ revolve(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `data` | [`RevolveData`](/docs/kcl/types/RevolveData) | Data for revolution surfaces. | Yes |
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | A sketch or a group of sketches. | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) |  | Yes |
 
 ### Returns
 
-[`SolidSet`](/docs/kcl/types/SolidSet) - A solid or a group of solids.
+[`[Solid]`](/docs/kcl/types/Solid)
 
 
 ### Examples

docs/kcl/rotate.md

@@ -24,7 +24,7 @@ When rotating a part around an axis, you specify the axis of rotation and the an
 
 ```js
 rotate(
-  solidSet: SolidOrImportedGeometry,
+  solids: SolidOrImportedGeometry,
   roll?: number,
   pitch?: number,
   yaw?: number,
@@ -39,7 +39,7 @@ rotate(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to rotate. | Yes |
+| `solids` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to rotate. | Yes |
 | `roll` | [`number`](/docs/kcl/types/number) | The roll angle in degrees. Must be used with `pitch` and `yaw`. Must be between -360 and 360. | No |
 | `pitch` | [`number`](/docs/kcl/types/number) | The pitch angle in degrees. Must be used with `roll` and `yaw`. Must be between -360 and 360. | No |
 | `yaw` | [`number`](/docs/kcl/types/number) | The yaw angle in degrees. Must be used with `roll` and `pitch`. Must be between -360 and 360. | No |

docs/kcl/scale.md

@@ -12,7 +12,7 @@ If you want to apply the transform in global space, set `global` to `true`. The
 
 ```js
 scale(
-  solidSet: SolidOrImportedGeometry,
+  solids: SolidOrImportedGeometry,
   scale: [number],
   global?: bool,
 ): SolidOrImportedGeometry
@@ -23,7 +23,7 @@ scale(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to scale. | Yes |
+| `solids` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to scale. | Yes |
 | `scale` | [`[number]`](/docs/kcl/types/number) | The scale factor for the x, y, and z axes. | Yes |
 | `global` | [`bool`](/docs/kcl/types/bool) | If true, the transform is applied in global space. The origin of the model will move. By default, the transform is applied in local sketch axis, therefore the origin will not move. | No |
 

docs/kcl/shell.md

@@ -10,10 +10,10 @@ Remove volume from a 3-dimensional shape such that a wall of the provided thickn
 
 ```js
 shell(
-  solidSet: SolidSet,
+  solids: [Solid],
   thickness: number,
   faces: [FaceTag],
-): SolidSet
+): [Solid]
 ```
 
 
@@ -21,13 +21,13 @@ shell(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidSet`](/docs/kcl/types/SolidSet) | Which solid (or solids) to shell out | Yes |
+| `solids` | [`[Solid]`](/docs/kcl/types/Solid) | Which solid (or solids) to shell out | Yes |
 | `thickness` | [`number`](/docs/kcl/types/number) | The thickness of the shell | Yes |
 | `faces` | [`[FaceTag]`](/docs/kcl/types/FaceTag) | The faces you want removed | Yes |
 
 ### Returns
 
-[`SolidSet`](/docs/kcl/types/SolidSet) - A solid or a group of solids.
+[`[Solid]`](/docs/kcl/types/Solid)
 
 
 ### Examples

docs/kcl/sweep.md

@@ -12,11 +12,11 @@ You can provide more than one sketch to sweep, and they will all be swept along
 
 ```js
 sweep(
-  sketchSet: SketchSet,
+  sketches: [Sketch],
   path: SweepPath,
   sectional?: bool,
   tolerance?: number,
-): SolidSet
+): [Solid]
 ```
 
 
@@ -24,14 +24,14 @@ sweep(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSet` | [`SketchSet`](/docs/kcl/types/SketchSet) | The sketch or set of sketches that should be swept in space | Yes |
+| `sketches` | [`[Sketch]`](/docs/kcl/types/Sketch) | The sketch or set of sketches that should be swept in space | Yes |
 | `path` | [`SweepPath`](/docs/kcl/types/SweepPath) | The path to sweep the sketch along | Yes |
 | `sectional` | [`bool`](/docs/kcl/types/bool) | If true, the sweep will be broken up into sub-sweeps (extrusions, revolves, sweeps) based on the trajectory path components. | No |
 | `tolerance` | [`number`](/docs/kcl/types/number) | Tolerance for this operation | No |
 
 ### Returns
 
-[`SolidSet`](/docs/kcl/types/SolidSet) - A solid or a group of solids.
+[`[Solid]`](/docs/kcl/types/Solid)
 
 
 ### Examples

docs/kcl/translate.md

@@ -10,7 +10,7 @@ Move a solid.
 
 ```js
 translate(
-  solidSet: SolidOrImportedGeometry,
+  solids: SolidOrImportedGeometry,
   translate: [number],
   global?: bool,
 ): SolidOrImportedGeometry
@@ -21,7 +21,7 @@ translate(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `solidSet` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to move. | Yes |
+| `solids` | [`SolidOrImportedGeometry`](/docs/kcl/types/SolidOrImportedGeometry) | The solid or set of solids to move. | Yes |
 | `translate` | [`[number]`](/docs/kcl/types/number) | The amount to move the solid in all three axes. | Yes |
 | `global` | [`bool`](/docs/kcl/types/bool) | If true, the transform is applied in global space. The origin of the model will move. By default, the transform is applied in local sketch axis, therefore the origin will not move. | No |
 

docs/kcl/types/KclValue.md

@@ -100,6 +100,22 @@ Any KCL value.
 
 
 
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `HomArray`|  | No |
+| `value` |`[` [`KclValue`](/docs/kcl/types/KclValue) `]`|  | No |
+
+
+----
+
+**Type:** `object`
+
+
+
+
+
 ## Properties
 
 | Property | Type | Description | Required |
@@ -122,7 +138,6 @@ Any KCL value.
 |----------|------|-------------|----------|
 | `type` |enum: [`TagIdentifier`](/docs/kcl/types#tag-identifier)|  | No |
 | `value` |[`string`](/docs/kcl/types/string)|  | No |
-| `info` |[`TagEngineInfo`](/docs/kcl/types/TagEngineInfo)|  | No |
 
 
 ----
@@ -200,22 +215,6 @@ Any KCL value.
 
 
 
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `Sketches`|  | No |
-| `value` |`[` [`Sketch`](/docs/kcl/types/Sketch) `]`|  | No |
-
-
-----
-
-**Type:** `object`
-
-
-
-
-
 ## Properties
 
 | Property | Type | Description | Required |
@@ -232,22 +231,6 @@ Any KCL value.
 
 
 
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `Solids`|  | No |
-| `value` |`[` [`Solid`](/docs/kcl/types/Solid) `]`|  | No |
-
-
-----
-
-**Type:** `object`
-
-
-
-
-
 ## Properties
 
 | Property | Type | Description | Required |
@@ -338,22 +321,6 @@ Data for an imported geometry.
 
 ----
 
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `Tombstone`|  | No |
-| `value` |`null`|  | No |
-
-
-----
-
 
 
 

docs/kcl/types/Path.md

@@ -126,6 +126,30 @@ A base path.
 | `__geoMeta` |[`GeoMeta`](/docs/kcl/types/GeoMeta)| Metadata. | No |
 
 
+----
+A base path.
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `ArcThreePoint`|  | No |
+| `p1` |`[number, number]`| Point 1 of the arc (base on the end of previous segment) | No |
+| `p2` |`[number, number]`| Point 2 of the arc (interior kwarg) | No |
+| `p3` |`[number, number]`| Point 3 of the arc (end kwarg) | No |
+| `from` |`[number, number]`| The from point. | No |
+| `to` |`[number, number]`| The to point. | No |
+| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
+| [`tag`](/docs/kcl/types/tag) |[`TagDeclarator`](/docs/kcl/types#tag-declaration)| The tag of the path. | No |
+| `__geoMeta` |[`GeoMeta`](/docs/kcl/types/GeoMeta)| Metadata. | No |
+
+
 ----
 A path that is horizontal.
 

docs/kcl/types/SketchSet.md

@@ -1,56 +0,0 @@
----
-title: "SketchSet"
-excerpt: "A sketch or a group of sketches."
-layout: manual
----
-
-A sketch or a group of sketches.
-
-
-
-
-
-**This schema accepts exactly one of the following:**
-
-
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `sketch`|  | No |
-| `id` |[`string`](/docs/kcl/types/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 |
-| `artifactId` |[`ArtifactId`](/docs/kcl/types/ArtifactId)| The original id of the sketch. This stays the same even if the sketch is is sketched on face etc. | No |
-| `originalId` |[`string`](/docs/kcl/types/string)|  | No |
-| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
-
-
-----
-
-**Type:** `[object, array]`
-
-`[` [`Sketch`](/docs/kcl/types/Sketch) `]`
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `sketches`|  | No |
-
-
-----
-
-
-
-

docs/kcl/types/SolidOrImportedGeometry.md

@@ -12,30 +12,6 @@ Data for a solid or an imported geometry.
 
 **This schema accepts exactly one of the following:**
 
-
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `solid`|  | No |
-| `id` |[`string`](/docs/kcl/types/string)| The id of the solid. | No |
-| `artifactId` |[`ArtifactId`](/docs/kcl/types/ArtifactId)| The artifact ID of the solid.  Unlike `id`, this doesn't change. | No |
-| `value` |`[` [`ExtrudeSurface`](/docs/kcl/types/ExtrudeSurface) `]`| The extrude surfaces. | No |
-| `sketch` |[`Sketch`](/docs/kcl/types/Sketch)| The sketch. | No |
-| `height` |[`number`](/docs/kcl/types/number)| The height of the solid. | No |
-| `startCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion start cap | No |
-| `endCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion end cap | No |
-| `edgeCuts` |`[` [`EdgeCut`](/docs/kcl/types/EdgeCut) `]`| Chamfers or fillets on this solid. | No |
-| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
-
-
-----
 Data for an imported geometry.
 
 **Type:** `object`

docs/kcl/types/SolidSet.md

@@ -1,57 +0,0 @@
----
-title: "SolidSet"
-excerpt: "A solid or a group of solids."
-layout: manual
----
-
-A solid or a group of solids.
-
-
-
-
-
-**This schema accepts exactly one of the following:**
-
-
-**Type:** `object`
-
-
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `solid`|  | No |
-| `id` |[`string`](/docs/kcl/types/string)| The id of the solid. | No |
-| `artifactId` |[`ArtifactId`](/docs/kcl/types/ArtifactId)| The artifact ID of the solid.  Unlike `id`, this doesn't change. | No |
-| `value` |`[` [`ExtrudeSurface`](/docs/kcl/types/ExtrudeSurface) `]`| The extrude surfaces. | No |
-| `sketch` |[`Sketch`](/docs/kcl/types/Sketch)| The sketch. | No |
-| `height` |[`number`](/docs/kcl/types/number)| The height of the solid. | No |
-| `startCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion start cap | No |
-| `endCapId` |[`string`](/docs/kcl/types/string)| The id of the extrusion end cap | No |
-| `edgeCuts` |`[` [`EdgeCut`](/docs/kcl/types/EdgeCut) `]`| Chamfers or fillets on this solid. | No |
-| `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
-
-
-----
-
-**Type:** `[object, array]`
-
-`[` [`Solid`](/docs/kcl/types/Solid) `]`
-
-
-
-## Properties
-
-| Property | Type | Description | Required |
-|----------|------|-------------|----------|
-| `type` |enum: `solids`|  | No |
-
-
-----
-
-
-
-

e2e/playwright/fixtures/toolbarFixture.ts

@@ -8,6 +8,7 @@ import {
 } from '../test-utils'
 import { SidebarType } from 'components/ModelingSidebar/ModelingPanes'
 import { SIDEBAR_BUTTON_SUFFIX } from 'lib/constants'
+import { ToolbarModeName } from 'lib/toolbar'
 
 export class ToolbarFixture {
   public page: Page
@@ -120,6 +121,15 @@ export class ToolbarFixture {
     // this is for the engine animation, as it takes 500ms to complete
     await this.page.waitForTimeout(600)
   }
+  private _getMode = () =>
+    this.page.locator('[data-current-mode]').getAttribute('data-current-mode')
+  expectToolbarMode = {
+    toBe: (mode: ToolbarModeName) => expect.poll(this._getMode).toEqual(mode),
+    not: {
+      toBe: (mode: ToolbarModeName) =>
+        expect.poll(this._getMode).not.toEqual(mode),
+    },
+  }
 
   private _serialiseFileTree = async () => {
     return this.page
@@ -176,6 +186,22 @@ export class ToolbarFixture {
     ).toBeVisible()
     await this.page.getByTestId('dropdown-circle-three-points').click()
   }
+  selectArc = async () => {
+    await this.page
+      .getByRole('button', { name: 'caret down Tangential Arc:' })
+      .click()
+    await expect(this.page.getByTestId('dropdown-arc')).toBeVisible()
+    await this.page.getByTestId('dropdown-arc').click()
+  }
+  selectThreePointArc = async () => {
+    await this.page
+      .getByRole('button', { name: 'caret down Tangential Arc:' })
+      .click()
+    await expect(
+      this.page.getByTestId('dropdown-three-point-arc')
+    ).toBeVisible()
+    await this.page.getByTestId('dropdown-three-point-arc').click()
+  }
 
   async closePane(paneId: SidebarType) {
     return closePane(this.page, paneId + SIDEBAR_BUTTON_SUFFIX)

e2e/playwright/point-click.spec.ts

@@ -850,159 +850,157 @@ openSketch = startSketchOn('XY')
     })
   })
 
-  test(`Shift-click to select and deselect sketch segments`, async ({
-    page,
-    homePage,
-    scene,
-    editor,
-  }) => {
-    // Locators
-    const firstPointLocation = { x: 200, y: 100 }
-    const secondPointLocation = { x: 800, y: 100 }
-    const thirdPointLocation = { x: 800, y: 400 }
-    const fristSegmentLocation = { x: 750, y: 100 }
-    const secondSegmentLocation = { x: 800, y: 150 }
-    const planeLocation = { x: 700, y: 200 }
+  test.fixme(
+    `Shift-click to select and deselect sketch segments`,
+    async ({ page, homePage, scene, editor }) => {
+      // Locators
+      const firstPointLocation = { x: 200, y: 100 }
+      const secondPointLocation = { x: 800, y: 100 }
+      const thirdPointLocation = { x: 800, y: 400 }
+      const fristSegmentLocation = { x: 750, y: 100 }
+      const secondSegmentLocation = { x: 800, y: 150 }
+      const planeLocation = { x: 700, y: 200 }
 
-    // Click helpers
-    const [clickFirstPoint] = scene.makeMouseHelpers(
-      firstPointLocation.x,
-      firstPointLocation.y
-    )
-    const [clickSecondPoint] = scene.makeMouseHelpers(
-      secondPointLocation.x,
-      secondPointLocation.y
-    )
-    const [clickThirdPoint] = scene.makeMouseHelpers(
-      thirdPointLocation.x,
-      thirdPointLocation.y
-    )
-    const [clickFirstSegment] = scene.makeMouseHelpers(
-      fristSegmentLocation.x,
-      fristSegmentLocation.y
-    )
-    const [clickSecondSegment] = scene.makeMouseHelpers(
-      secondSegmentLocation.x,
-      secondSegmentLocation.y
-    )
-    const [clickPlane] = scene.makeMouseHelpers(
-      planeLocation.x,
-      planeLocation.y
-    )
-
-    // Colors
-    const edgeColorWhite: [number, number, number] = [220, 220, 220]
-    const edgeColorBlue: [number, number, number] = [20, 20, 200]
-    const backgroundColor: [number, number, number] = [30, 30, 30]
-    const tolerance = 40
-    const timeout = 150
-
-    // Setup
-    await test.step(`Initial test setup`, async () => {
-      await page.setBodyDimensions({ width: 1000, height: 500 })
-      await homePage.goToModelingScene()
-
-      // Wait for the scene and stream to load
-      await scene.expectPixelColor(
-        backgroundColor,
-        secondPointLocation,
-        tolerance
+      // Click helpers
+      const [clickFirstPoint] = scene.makeMouseHelpers(
+        firstPointLocation.x,
+        firstPointLocation.y
+      )
+      const [clickSecondPoint] = scene.makeMouseHelpers(
+        secondPointLocation.x,
+        secondPointLocation.y
+      )
+      const [clickThirdPoint] = scene.makeMouseHelpers(
+        thirdPointLocation.x,
+        thirdPointLocation.y
+      )
+      const [clickFirstSegment] = scene.makeMouseHelpers(
+        fristSegmentLocation.x,
+        fristSegmentLocation.y
+      )
+      const [clickSecondSegment] = scene.makeMouseHelpers(
+        secondSegmentLocation.x,
+        secondSegmentLocation.y
+      )
+      const [clickPlane] = scene.makeMouseHelpers(
+        planeLocation.x,
+        planeLocation.y
       )
-    })
 
-    await test.step('Select and deselect a single sketch segment', async () => {
-      await test.step('Get into sketch mode', async () => {
-        await editor.closePane()
-        await page.waitForTimeout(timeout)
-        await page.getByRole('button', { name: 'Start Sketch' }).click()
-        await page.waitForTimeout(timeout)
-        await clickPlane()
-        await page.waitForTimeout(1000)
-      })
-      await test.step('Draw sketch', async () => {
-        await clickFirstPoint()
-        await page.waitForTimeout(timeout)
-        await clickSecondPoint()
-        await page.waitForTimeout(timeout)
-        await clickThirdPoint()
-        await page.waitForTimeout(timeout)
-      })
-      await test.step('Deselect line tool', async () => {
-        const btnLine = page.getByTestId('line')
-        const btnLineAriaPressed = await btnLine.getAttribute('aria-pressed')
-        if (btnLineAriaPressed === 'true') {
-          await btnLine.click()
-        }
-        await page.waitForTimeout(timeout)
-      })
-      await test.step('Select the first segment', async () => {
-        await page.waitForTimeout(timeout)
-        await clickFirstSegment()
-        await page.waitForTimeout(timeout)
+      // Colors
+      const edgeColorWhite: [number, number, number] = [220, 220, 220]
+      const edgeColorBlue: [number, number, number] = [20, 20, 200]
+      const backgroundColor: [number, number, number] = [30, 30, 30]
+      const tolerance = 40
+      const timeout = 150
+
+      // Setup
+      await test.step(`Initial test setup`, async () => {
+        await page.setBodyDimensions({ width: 1000, height: 500 })
+        await homePage.goToModelingScene()
+
+        // Wait for the scene and stream to load
         await scene.expectPixelColor(
-          edgeColorBlue,
-          fristSegmentLocation,
-          tolerance
-        )
-        await scene.expectPixelColor(
-          edgeColorWhite,
-          secondSegmentLocation,
+          backgroundColor,
+          secondPointLocation,
           tolerance
         )
       })
-      await test.step('Select the second segment (Shift-click)', async () => {
-        await page.keyboard.down('Shift')
-        await page.waitForTimeout(timeout)
-        await clickSecondSegment()
-        await page.waitForTimeout(timeout)
-        await page.keyboard.up('Shift')
-        await scene.expectPixelColor(
-          edgeColorBlue,
-          fristSegmentLocation,
-          tolerance
-        )
-        await scene.expectPixelColor(
-          edgeColorBlue,
-          secondSegmentLocation,
-          tolerance
-        )
+
+      await test.step('Select and deselect a single sketch segment', async () => {
+        await test.step('Get into sketch mode', async () => {
+          await editor.closePane()
+          await page.waitForTimeout(timeout)
+          await page.getByRole('button', { name: 'Start Sketch' }).click()
+          await page.waitForTimeout(timeout)
+          await clickPlane()
+          await page.waitForTimeout(1000)
+        })
+        await test.step('Draw sketch', async () => {
+          await clickFirstPoint()
+          await page.waitForTimeout(timeout)
+          await clickSecondPoint()
+          await page.waitForTimeout(timeout)
+          await clickThirdPoint()
+          await page.waitForTimeout(timeout)
+        })
+        await test.step('Deselect line tool', async () => {
+          const btnLine = page.getByTestId('line')
+          const btnLineAriaPressed = await btnLine.getAttribute('aria-pressed')
+          if (btnLineAriaPressed === 'true') {
+            await btnLine.click()
+          }
+          await page.waitForTimeout(timeout)
+        })
+        await test.step('Select the first segment', async () => {
+          await page.waitForTimeout(timeout)
+          await clickFirstSegment()
+          await page.waitForTimeout(timeout)
+          await scene.expectPixelColor(
+            edgeColorBlue,
+            fristSegmentLocation,
+            tolerance
+          )
+          await scene.expectPixelColor(
+            edgeColorWhite,
+            secondSegmentLocation,
+            tolerance
+          )
+        })
+        await test.step('Select the second segment (Shift-click)', async () => {
+          await page.keyboard.down('Shift')
+          await page.waitForTimeout(timeout)
+          await clickSecondSegment()
+          await page.waitForTimeout(timeout)
+          await page.keyboard.up('Shift')
+          await scene.expectPixelColor(
+            edgeColorBlue,
+            fristSegmentLocation,
+            tolerance
+          )
+          await scene.expectPixelColor(
+            edgeColorBlue,
+            secondSegmentLocation,
+            tolerance
+          )
+        })
+        await test.step('Deselect the first segment', async () => {
+          await page.keyboard.down('Shift')
+          await page.waitForTimeout(timeout)
+          await clickFirstSegment()
+          await page.waitForTimeout(timeout)
+          await page.keyboard.up('Shift')
+          await scene.expectPixelColor(
+            edgeColorWhite,
+            fristSegmentLocation,
+            tolerance
+          )
+          await scene.expectPixelColor(
+            edgeColorBlue,
+            secondSegmentLocation,
+            tolerance
+          )
+        })
+        await test.step('Deselect the second segment', async () => {
+          await page.keyboard.down('Shift')
+          await page.waitForTimeout(timeout)
+          await clickSecondSegment()
+          await page.waitForTimeout(timeout)
+          await page.keyboard.up('Shift')
+          await scene.expectPixelColor(
+            edgeColorWhite,
+            fristSegmentLocation,
+            tolerance
+          )
+          await scene.expectPixelColor(
+            edgeColorWhite,
+            secondSegmentLocation,
+            tolerance
+          )
+        })
       })
-      await test.step('Deselect the first segment', async () => {
-        await page.keyboard.down('Shift')
-        await page.waitForTimeout(timeout)
-        await clickFirstSegment()
-        await page.waitForTimeout(timeout)
-        await page.keyboard.up('Shift')
-        await scene.expectPixelColor(
-          edgeColorWhite,
-          fristSegmentLocation,
-          tolerance
-        )
-        await scene.expectPixelColor(
-          edgeColorBlue,
-          secondSegmentLocation,
-          tolerance
-        )
-      })
-      await test.step('Deselect the second segment', async () => {
-        await page.keyboard.down('Shift')
-        await page.waitForTimeout(timeout)
-        await clickSecondSegment()
-        await page.waitForTimeout(timeout)
-        await page.keyboard.up('Shift')
-        await scene.expectPixelColor(
-          edgeColorWhite,
-          fristSegmentLocation,
-          tolerance
-        )
-        await scene.expectPixelColor(
-          edgeColorWhite,
-          secondSegmentLocation,
-          tolerance
-        )
-      })
-    })
-  })
+    }
+  )
 
   test(`Offset plane point-and-click`, async ({
     context,
@@ -1024,7 +1022,7 @@ openSketch = startSketchOn('XY')
     await page.waitForTimeout(15000)
 
     await test.step(`Look for the blue of the XZ plane`, async () => {
-      await scene.expectPixelColor([50, 51, 96], testPoint, 15)
+      //await scene.expectPixelColor([50, 51, 96], testPoint, 15) // FIXME
     })
     await test.step(`Go through the command bar flow`, async () => {
       await toolbar.offsetPlaneButton.click()
@@ -1066,7 +1064,7 @@ openSketch = startSketchOn('XY')
       )
       await operationButton.click({ button: 'left' })
       await page.keyboard.press('Delete')
-      await scene.expectPixelColor([50, 51, 96], testPoint, 15)
+      //await scene.expectPixelColor([50, 51, 96], testPoint, 15) // FIXME
     })
   })
 
@@ -2271,8 +2269,8 @@ chamfer04 = chamfer(extrude001, length = 5, tags = [getOppositeEdge(seg02)])
       cmdBar,
     }) => {
       const initialCode = `sketch001 = startSketchOn('XZ')
-    |> circle(center = [0, 0], radius = 30)
-    extrude001 = extrude(sketch001, length = 30)
+  |> circle(center = [0, 0], radius = 30)
+extrude001 = extrude(sketch001, length = 30)
     `
       await context.addInitScript((initialCode) => {
         localStorage.setItem('persistCode', initialCode)
@@ -2286,6 +2284,8 @@ chamfer04 = chamfer(extrude001, length = 5, tags = [getOppositeEdge(seg02)])
       const [clickOnCap] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
       const shellDeclaration =
         "shell001 = shell(extrude001, faces = ['end'], thickness = 5)"
+      const editedShellDeclaration =
+        "shell001 = shell(extrude001, faces = ['end'], thickness = 2)"
 
       await test.step(`Look for the grey of the shape`, async () => {
         await scene.expectPixelColor([127, 127, 127], testPoint, 15)
@@ -2352,6 +2352,45 @@ chamfer04 = chamfer(extrude001, length = 5, tags = [getOppositeEdge(seg02)])
         })
         await scene.expectPixelColor([146, 146, 146], testPoint, 15)
       })
+
+      await test.step('Edit shell via feature tree selection works', async () => {
+        await toolbar.closePane('code')
+        await toolbar.openPane('feature-tree')
+        const operationButton = await toolbar.getFeatureTreeOperation(
+          'Shell',
+          0
+        )
+        await operationButton.dblclick()
+        await cmdBar.expectState({
+          stage: 'arguments',
+          currentArgKey: 'thickness',
+          currentArgValue: '5',
+          headerArguments: {
+            Thickness: '5',
+          },
+          highlightedHeaderArg: 'thickness',
+          commandName: 'Shell',
+        })
+        await page.keyboard.insertText('2')
+        await cmdBar.progressCmdBar()
+        await cmdBar.expectState({
+          stage: 'review',
+          headerArguments: {
+            Thickness: '2',
+          },
+          commandName: 'Shell',
+        })
+        await cmdBar.progressCmdBar()
+        await toolbar.closePane('feature-tree')
+        await scene.expectPixelColor([150, 150, 150], testPoint, 15)
+        await toolbar.openPane('code')
+        await editor.expectEditor.toContain(editedShellDeclaration)
+        await editor.expectState({
+          diagnostics: [],
+          activeLines: [editedShellDeclaration],
+          highlightedCode: '',
+        })
+      })
     })
   })
 
@@ -2387,6 +2426,8 @@ extrude001 = extrude(sketch001, length = 40)
     const mutatedCode = 'xLine(length = -40, tag = $seg01)'
     const shellDeclaration =
       "shell001 = shell(extrude001, faces = ['end', seg01], thickness = 5)"
+    const editedShellDeclaration =
+      "shell001 = shell(extrude001, faces = ['end', seg01], thickness = 1)"
 
     await test.step(`Look for the grey of the shape`, async () => {
       await scene.expectPixelColor([99, 99, 99], testPoint, 15)
@@ -2435,6 +2476,41 @@ extrude001 = extrude(sketch001, length = 40)
       await scene.expectPixelColor([49, 49, 49], testPoint, 15)
     })
 
+    await test.step('Edit shell via feature tree selection works', async () => {
+      await editor.closePane()
+      const operationButton = await toolbar.getFeatureTreeOperation('Shell', 0)
+      await operationButton.dblclick({ button: 'left' })
+      await cmdBar.expectState({
+        stage: 'arguments',
+        currentArgKey: 'thickness',
+        currentArgValue: '5',
+        headerArguments: {
+          Thickness: '5',
+        },
+        highlightedHeaderArg: 'thickness',
+        commandName: 'Shell',
+      })
+      await page.keyboard.insertText('1')
+      await cmdBar.progressCmdBar()
+      await cmdBar.expectState({
+        stage: 'review',
+        headerArguments: {
+          Thickness: '1',
+        },
+        commandName: 'Shell',
+      })
+      await cmdBar.progressCmdBar()
+      await toolbar.closePane('feature-tree')
+      await scene.expectPixelColor([150, 150, 150], testPoint, 15)
+      await toolbar.openPane('code')
+      await editor.expectEditor.toContain(editedShellDeclaration)
+      await editor.expectState({
+        diagnostics: [],
+        activeLines: [editedShellDeclaration],
+        highlightedCode: '',
+      })
+    })
+
     await test.step('Delete shell via feature tree selection', async () => {
       await editor.closePane()
       const operationButton = await toolbar.getFeatureTreeOperation('Shell', 0)
@@ -2529,7 +2605,7 @@ extrude002 = extrude(sketch002, length = 50)
           highlightedCode: '',
         })
         await toolbar.closePane('code')
-        await scene.expectPixelColor([73, 73, 73], testPoint, 15)
+        await scene.expectPixelColor([80, 80, 80], testPoint, 15)
       })
     })
   })

e2e/playwright/prompt-to-edit-snapshot-tests.spec.ts

@@ -53,46 +53,47 @@ sketch003 = startSketchOn('XY')
   |> close()
 extrude003 = extrude(sketch003, length = 20)
 `
+test.describe('edit with AI example snapshots', () => {
+  test(
+    `change colour`,
+    { tag: '@snapshot' },
+    async ({ context, homePage, cmdBar, editor, page, scene }) => {
+      await context.addInitScript((file) => {
+        localStorage.setItem('persistCode', file)
+      }, file)
+      await homePage.goToModelingScene()
+      await scene.waitForExecutionDone()
 
-test(
-  `change colour`,
-  { tag: '@snapshot' },
-  async ({ context, homePage, cmdBar, editor, page, scene }) => {
-    await context.addInitScript((file) => {
-      localStorage.setItem('persistCode', file)
-    }, file)
-    await homePage.goToModelingScene()
-    await scene.waitForExecutionDone()
+      const body1CapCoords = { x: 571, y: 351 }
+      const [clickBody1Cap] = scene.makeMouseHelpers(
+        body1CapCoords.x,
+        body1CapCoords.y
+      )
+      const yellow: [number, number, number] = [179, 179, 131]
+      const submittingToast = page.getByText('Submitting to Text-to-CAD API...')
 
-    const body1CapCoords = { x: 571, y: 351 }
-    const [clickBody1Cap] = scene.makeMouseHelpers(
-      body1CapCoords.x,
-      body1CapCoords.y
-    )
-    const yellow: [number, number, number] = [179, 179, 131]
-    const submittingToast = page.getByText('Submitting to Text-to-CAD API...')
-
-    await test.step('wait for scene to load select body and check selection came through', async () => {
-      await scene.expectPixelColor([134, 134, 134], body1CapCoords, 15)
-      await clickBody1Cap()
-      await scene.expectPixelColor(yellow, body1CapCoords, 20)
-      await editor.expectState({
-        highlightedCode: '',
-        activeLines: ['|>startProfileAt([-73.64,-42.89],%)'],
-        diagnostics: [],
+      await test.step('wait for scene to load select body and check selection came through', async () => {
+        await scene.expectPixelColor([134, 134, 134], body1CapCoords, 15)
+        await clickBody1Cap()
+        await scene.expectPixelColor(yellow, body1CapCoords, 20)
+        await editor.expectState({
+          highlightedCode: '',
+          activeLines: ['|>startProfileAt([-73.64,-42.89],%)'],
+          diagnostics: [],
+        })
       })
-    })
 
-    await test.step('fire off edit prompt', async () => {
-      await cmdBar.captureTextToCadRequestSnapshot(test.info())
-      await cmdBar.openCmdBar('promptToEdit')
-      // being specific about the color with a hex means asserting pixel color is more stable
-      await page
-        .getByTestId('cmd-bar-arg-value')
-        .fill('make this neon green please, use #39FF14')
-      await page.waitForTimeout(100)
-      await cmdBar.progressCmdBar()
-      await expect(submittingToast).toBeVisible()
-    })
-  }
-)
+      await test.step('fire off edit prompt', async () => {
+        await cmdBar.captureTextToCadRequestSnapshot(test.info())
+        await cmdBar.openCmdBar('promptToEdit')
+        // being specific about the color with a hex means asserting pixel color is more stable
+        await page
+          .getByTestId('cmd-bar-arg-value')
+          .fill('make this neon green please, use #39FF14')
+        await page.waitForTimeout(100)
+        await cmdBar.progressCmdBar()
+        await expect(submittingToast).toBeVisible()
+      })
+    }
+  )
+})

e2e/playwright/prompt-to-edit.spec.ts

@@ -35,7 +35,7 @@ sketch003 = startSketchOn('XY')
 extrude003 = extrude(sketch003, length = 20)
 `
 
-test.describe('Prompt-to-edit tests', { tag: '@skipWin' }, () => {
+test.fixme('Prompt-to-edit tests', { tag: '@skipWin' }, () => {
   test.describe('Check the happy path, for basic changing color', () => {
     const cases = [
       {

e2e/playwright/regression-tests.spec.ts

@@ -319,7 +319,6 @@ extrude001 = extrude(sketch001, length = 50)
     'when engine fails export we handle the failure and alert the user',
     { tag: '@skipLocalEngine' },
     async ({ scene, page, homePage, cmdBar }) => {
-      const u = await getUtils(page)
       await page.addInitScript(
         async ({ code }) => {
           localStorage.setItem('persistCode', code)
@@ -492,7 +491,7 @@ extrude001 = extrude(sketch001, length = 50)
     }
   )
 
-  test(
+  test.fixme(
     `Network health indicator only appears in modeling view`,
     { tag: '@electron' },
     async ({ context, page }, testInfo) => {
@@ -636,11 +635,8 @@ extrude001 = extrude(sketch001, length = 50)
       await homePage.goToModelingScene()
     })
 
-    const toolBarMode = () =>
-      page.locator('[data-currentMode]').getAttribute('data-currentMode')
-
     await test.step('Start sketch and select a plane', async () => {
-      await expect.poll(toolBarMode).toEqual('modeling')
+      await toolbar.expectToolbarMode.toBe('modeling')
       // Click the start sketch button
       await toolbar.startSketchPlaneSelection()
 
@@ -649,10 +645,10 @@ extrude001 = extrude(sketch001, length = 50)
 
       // Check that the modeling toolbar doesn't appear during the animation
       // The animation typically takes around 500ms, so we'll check for a second
-      await expect.poll(toolBarMode, { timeout: 1000 }).not.toEqual('modeling')
+      await toolbar.expectToolbarMode.not.toBe('modeling')
 
       // After animation completes, we should see the sketching toolbar
-      await expect.poll(toolBarMode).toEqual('sketching')
+      await toolbar.expectToolbarMode.toBe('sketching')
     })
   })
 

e2e/playwright/secrets.ts

@@ -1,8 +1,9 @@
 import { readFileSync } from 'fs'
 
 const secrets: Record<string, string> = {}
+const secretsPath = './e2e/playwright/playwright-secrets.env'
 try {
-  const file = readFileSync('./e2e/playwright/playwright-secrets.env', 'utf8')
+  const file = readFileSync(secretsPath, 'utf8')
   file
     .split('\n')
     .filter((line) => line && line.length > 1)
@@ -15,9 +16,12 @@ try {
     })
 } catch (err) {
   // probably running in CI
-  secrets.token = process.env.token || ''
-  secrets.snapshottoken = process.env.snapshottoken || ''
-  // add more env vars here to make them available in CI
+  console.warn(
+    `Error reading ${secretsPath}; environment variables will be used`
+  )
 }
+secrets.token = secrets.token || process.env.token || ''
+secrets.snapshottoken = secrets.snapshottoken || process.env.snapshottoken || ''
+// add more env vars here to make them available in CI
 
 export { secrets }

e2e/playwright/sketch-tests.spec.ts

@@ -12,6 +12,7 @@ import {
 } from './test-utils'
 import { uuidv4, roundOff } from 'lib/utils'
 import { SceneFixture } from './fixtures/sceneFixture'
+import { CmdBarFixture } from './fixtures/cmdBarFixture'
 
 test.describe('Sketch tests', { tag: ['@skipWin'] }, () => {
   test('multi-sketch file shows multiple Edit Sketch buttons', async ({
@@ -191,7 +192,8 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
       page: Page,
       homePage: HomePageFixture,
       openPanes: string[],
-      scene: SceneFixture
+      scene: SceneFixture,
+      cmdBar: CmdBarFixture
     ) => {
       // Load the app with the code panes
       await page.addInitScript(async () => {
@@ -201,13 +203,22 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
       |> startProfileAt([4.61, -14.01], %)
       |> line(end = [12.73, -0.09])
       |> tangentialArcTo([24.95, -5.38], %)
+      |> arcTo({
+          interior = [20.18, -1.7],
+          end = [11.82, -1.16]
+        }, %)
+      |> arc({
+          radius = 5.92,
+          angleStart = -89.36,
+          angleEnd = 135.81
+        }, %)
       |> close()`
         )
       })
 
       const u = await getUtils(page)
       await homePage.goToModelingScene()
-      await scene.waitForExecutionDone()
+      await scene.settled(cmdBar)
 
       await expect(
         page.getByRole('button', { name: 'Start Sketch' })
@@ -242,7 +253,17 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
       |> startProfileAt([4.61, -14.01], %)
       |> line(end = [12.73, -0.09])
       |> tangentialArcTo([24.95, -5.38], %)
-      |> close()`)
+      |> arcTo({
+          interior = [20.18, -1.7],
+          end = [11.82, -1.16]
+        }, %)
+      |> arc({
+          radius = 5.92,
+          angleStart = -89.36,
+          angleEnd = 135.81
+        }, %)
+      |> close()
+`)
       } else {
         // Ensure we don't see the code.
         await expect(u.codeLocator).not.toBeVisible()
@@ -272,7 +293,7 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
 
       const step5 = { steps: 5 }
 
-      await expect(page.getByTestId('segment-overlay')).toHaveCount(2)
+      await expect(page.getByTestId('segment-overlay')).toHaveCount(5)
 
       // drag startProfileAt handle
       await page.mouse.move(startPX[0], startPX[1])
@@ -310,22 +331,93 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
         await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
       }
 
+      // drag arcTo interior handle (three point arc)
+      const arcToHandle = await u.getBoundingBox('[data-overlay-index="2"]')
+      await page.mouse.move(arcToHandle.x, arcToHandle.y - 5)
+      await page.mouse.down()
+      await page.mouse.move(
+        arcToHandle.x - dragPX,
+        arcToHandle.y + dragPX,
+        step5
+      )
+      await page.mouse.up()
+      await page.waitForTimeout(100)
+      if (openPanes.includes('code')) {
+        await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+        prevContent = await page.locator('.cm-content').innerText()
+      }
+
+      // drag arcTo end handle (three point arc)
+      const arcToEndHandle = await u.getBoundingBox('[data-overlay-index="3"]')
+      await page.mouse.move(arcToEndHandle.x, arcToEndHandle.y - 5)
+      await page.mouse.down()
+      await page.mouse.move(
+        arcToEndHandle.x - dragPX,
+        arcToEndHandle.y + dragPX,
+        step5
+      )
+      await page.mouse.up()
+      await page.waitForTimeout(100)
+      if (openPanes.includes('code')) {
+        await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+        prevContent = await page.locator('.cm-content').innerText()
+      }
+
+      // drag arc radius handle
+      const arcRadiusHandle = await u.getBoundingBox('[data-overlay-index="4"]')
+      await page.mouse.move(arcRadiusHandle.x, arcRadiusHandle.y - 5)
+      await page.mouse.down()
+      await page.mouse.move(
+        arcRadiusHandle.x - dragPX,
+        arcRadiusHandle.y + dragPX,
+        step5
+      )
+      await page.mouse.up()
+      await page.waitForTimeout(100)
+      if (openPanes.includes('code')) {
+        await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+      }
+
+      // drag arc center handle (we'll have to hardcode the position because it doesn't have a overlay near the handle)
+      const arcCenterHandle = { x: 745, y: 214 }
+      await page.mouse.move(arcCenterHandle.x, arcCenterHandle.y - 5)
+      await page.mouse.down()
+      await page.mouse.move(
+        arcCenterHandle.x - dragPX,
+        arcCenterHandle.y + dragPX,
+        step5
+      )
+      await page.mouse.up()
+      await page.waitForTimeout(100)
+      if (openPanes.includes('code')) {
+        await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+      }
+
       // Open the code pane
       await u.openKclCodePanel()
 
       // expect the code to have changed
       await expect(page.locator('.cm-content'))
         .toHaveText(`sketch001 = startSketchOn('XZ')
-      |> startProfileAt([6.44, -12.07], %)
-      |> line(end = [14.72, 1.97])
-      |> tangentialArcTo([24.95, -5.38], %)
-      |> line(end = [1.97, 2.06])
-      |> close()`)
+  |> startProfileAt([6.44, -12.07], %)
+  |> line(end = [14.72, 1.97])
+  |> tangentialArcTo([26.92, -3.32], %)
+  |> arcTo({
+       interior = [18.11, -3.73],
+       end = [9.77, -3.19]
+     }, %)
+  |> arc({
+       radius = 3.75,
+       angleStart = -58.29,
+       angleEnd = 161.17
+     }, %)
+  |> close()
+`)
     }
     test(
       'code pane open at start-handles',
       { tag: ['@skipWin'] },
-      async ({ page, homePage, scene }) => {
+      async ({ page, homePage, scene, cmdBar }) => {
         // Load the app with the code panes
         await page.addInitScript(async () => {
           localStorage.setItem(
@@ -338,14 +430,20 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
             })
           )
         })
-        await doEditSegmentsByDraggingHandle(page, homePage, ['code'], scene)
+        await doEditSegmentsByDraggingHandle(
+          page,
+          homePage,
+          ['code'],
+          scene,
+          cmdBar
+        )
       }
     )
 
     test(
       'code pane closed at start-handles',
       { tag: ['@skipWin'] },
-      async ({ page, homePage, scene }) => {
+      async ({ page, homePage, scene, cmdBar }) => {
         // Load the app with the code panes
         await page.addInitScript(async (persistModelingContext) => {
           localStorage.setItem(
@@ -353,7 +451,7 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
             JSON.stringify({ openPanes: [] })
           )
         }, PERSIST_MODELING_CONTEXT)
-        await doEditSegmentsByDraggingHandle(page, homePage, [], scene)
+        await doEditSegmentsByDraggingHandle(page, homePage, [], scene, cmdBar)
       }
     )
   })
@@ -362,6 +460,8 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
     page,
     editor,
     homePage,
+    scene,
+    cmdBar,
   }) => {
     const u = await getUtils(page)
     await page.addInitScript(async () => {
@@ -373,6 +473,8 @@ sketch001 = startProfileAt([12.34, -12.34], sketch002)
     })
 
     await homePage.goToModelingScene()
+    await scene.connectionEstablished()
+    await scene.settled(cmdBar)
 
     await expect(
       page.getByRole('button', { name: 'Start Sketch' })
@@ -1174,7 +1276,7 @@ profile001 = startProfileAt([${roundOff(scale * 69.6)}, ${roundOff(
     |> line(endAbsolute = [
      railWideWidth / 2,
      railClampable / 2 + railBaseLength
-   ], $seg01)
+   ], tag = $seg01)
     |> line(endAbsolute = [railTop / 2, railBaseLength])
     |> line(endAbsolute = [railBaseWidth / 2, railBaseLength])
     |> line(endAbsolute = [railBaseWidth / 2, 0])
@@ -1355,7 +1457,7 @@ test.describe('multi-profile sketching', () => {
   test(
     `test it removes half-finished expressions when changing tools in sketch mode`,
     { tag: ['@skipWin'] },
-    async ({ context, page, scene, toolbar, editor, homePage }) => {
+    async ({ context, page, scene, toolbar, editor, homePage, cmdBar }) => {
       // We seed the scene with a single offset plane
       await context.addInitScript(() => {
         localStorage.setItem(
@@ -1375,7 +1477,10 @@ profile002 = startProfileAt([117.2, 56.08], sketch001)
         )
       })
 
+      const [continueProfile2Clk] = scene.makeMouseHelpers(954, 282)
+
       await homePage.goToModelingScene()
+      await scene.settled(cmdBar)
       await expect(
         page.getByRole('button', { name: 'Start Sketch' })
       ).not.toBeDisabled()
@@ -1386,7 +1491,13 @@ profile002 = startProfileAt([117.2, 56.08], sketch001)
       const [circlePoint1] = scene.makeMouseHelpers(700, 200)
 
       await test.step('equip circle tool and click first point', async () => {
-        await toolbar.circleBtn.click()
+        // await page.waitForTimeout(100)
+        await expect
+          .poll(async () => {
+            await toolbar.circleBtn.click()
+            return toolbar.circleBtn.getAttribute('aria-pressed')
+          })
+          .toBe('true')
         await page.waitForTimeout(100)
         await circlePoint1()
         await editor.expectEditor.toContain(
@@ -1401,6 +1512,7 @@ profile002 = startProfileAt([117.2, 56.08], sketch001)
 
       const [circle3Point1] = scene.makeMouseHelpers(650, 200)
       const [circle3Point2] = scene.makeMouseHelpers(750, 200)
+      // const [circle3Point3] = scene.makeMouseHelpers(700, 150)
 
       await test.step('equip three point circle tool and click first two points', async () => {
         await toolbar.selectCircleThreePoint()
@@ -1411,25 +1523,40 @@ profile002 = startProfileAt([117.2, 56.08], sketch001)
         await editor.expectEditor.toContain('profile003 = circleThreePoint(')
       })
 
-      await test.step('equip line tool and verify three point circle code is removed', async () => {
+      await test.step('equip line tool and verify three-point circle code is removed', async () => {
         await toolbar.lineBtn.click()
         await editor.expectEditor.not.toContain(
           'profile003 = circleThreePoint('
         )
       })
 
+      await test.step('equip three-point-arc tool and click first two points', async () => {
+        await page.waitForTimeout(200)
+        await toolbar.selectThreePointArc()
+        await page.waitForTimeout(200)
+        await circle3Point1()
+        await page.waitForTimeout(200)
+        await circle3Point2()
+        await editor.expectEditor.toContain('arcTo({')
+      })
+
+      await test.step('equip line tool and verify three-point-arc code is removed after second click', async () => {
+        await toolbar.lineBtn.click()
+        await editor.expectEditor.not.toContain('arcTo({')
+      })
+
       const [cornerRectPoint1] = scene.makeMouseHelpers(600, 300)
 
       await test.step('equip corner rectangle tool and click first point', async () => {
         await toolbar.rectangleBtn.click()
         await page.waitForTimeout(100)
         await cornerRectPoint1()
-        await editor.expectEditor.toContain('profile003 = startProfileAt(')
+        await editor.expectEditor.toContain('profile004 = startProfileAt(')
       })
 
       await test.step('equip line tool and verify corner rectangle code is removed', async () => {
         await toolbar.lineBtn.click()
-        await editor.expectEditor.not.toContain('profile003 = startProfileAt(')
+        await editor.expectEditor.not.toContain('profile004 = startProfileAt(')
       })
 
       const [centerRectPoint1] = scene.makeMouseHelpers(700, 300)
@@ -1438,12 +1565,24 @@ profile002 = startProfileAt([117.2, 56.08], sketch001)
         await toolbar.selectCenterRectangle()
         await page.waitForTimeout(100)
         await centerRectPoint1()
-        await editor.expectEditor.toContain('profile003 = startProfileAt(')
+        await editor.expectEditor.toContain('profile004 = startProfileAt(')
       })
 
       await test.step('equip line tool and verify center rectangle code is removed', async () => {
         await toolbar.lineBtn.click()
-        await editor.expectEditor.not.toContain('profile003 = startProfileAt(')
+        await editor.expectEditor.not.toContain('profile004 = startProfileAt(')
+      })
+
+      await test.step('continue profile002 with the three point arc tool, and then switch back to the line tool to verify it only removes the last expression in the pipe', async () => {
+        await toolbar.selectThreePointArc()
+        await page.waitForTimeout(200)
+        await continueProfile2Clk()
+        await page.waitForTimeout(200)
+        await circle3Point1()
+        await editor.expectEditor.toContain('arcTo({')
+        await toolbar.lineBtn.click()
+        await editor.expectEditor.not.toContain('arcTo({')
+        await editor.expectEditor.toContain('profile002')
       })
     }
   )
@@ -1532,6 +1671,7 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
   }) => {
     await page.setBodyDimensions({ width: 1000, height: 500 })
     await homePage.goToModelingScene()
+    await scene.connectionEstablished()
     await expect(
       page.getByRole('button', { name: 'Start Sketch' })
     ).not.toBeDisabled()
@@ -1595,7 +1735,7 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
     // timeout wait for engine animation is unavoidable
     await page.waitForTimeout(600)
     await editor.expectEditor.toContain(`sketch001 = startSketchOn('XZ')`)
-    await test.step('Create a close profile stopping mid profile to equip the tangential arc, and than back to the line tool', async () => {
+    await test.step('Create a close profile stopping mid profile to equip the tangential arc, then three-point arc, and then back to the line tool', async () => {
       await startProfile1()
       await editor.expectEditor.toContain(
         `profile001 = startProfileAt([4.61, 12.21], sketch001)`
@@ -1613,12 +1753,45 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
       await editor.expectEditor.toContain(
         `|> tangentialArcTo([16.61, 4.14], %)`
       )
+
+      // Add a three-point arc segment
+      await toolbar.selectThreePointArc()
+      await page.waitForTimeout(300)
+
+      // select end of profile again
+      await endLineStartTanArc()
+      await page.waitForTimeout(300)
+
+      // Define points for the three-point arc
+      const [threePointInterior, threePointInteriorMove] =
+        scene.makeMouseHelpers(600, 200)
+      const [threePointEnd, threePointEndMove] = scene.makeMouseHelpers(
+        590,
+        270
+      )
+
+      // Create the three-point arc
+      await page.waitForTimeout(300)
+      await threePointInteriorMove()
+      await threePointInterior()
+      await page.waitForTimeout(300)
+      await threePointEndMove()
+      await threePointEnd()
+      await page.waitForTimeout(300)
+
+      // Verify the three-point arc was created correctly
+      await editor.expectEditor.toContain(`|> arcTo(`)
+
+      // Switch back to line tool to continue
       await toolbar.lineBtn.click()
       await page.waitForTimeout(300)
-      await endArcStartLine()
+
+      // Continue with the original line segment
+      await threePointEnd()
+      await page.waitForTimeout(300)
 
       await page.mouse.click(572, 110)
-      await editor.expectEditor.toContain(`|> line(end = [-11.73, 5.35])`)
+      await editor.expectEditor.toContain(`|> line(end = [-1.22, 10.85])`)
       await startProfile1()
       await editor.expectEditor.toContain(
         `|> line(endAbsolute = [profileStartX(%), profileStartY(%)])
@@ -1820,8 +1993,68 @@ profile003 = startProfileAt([206.63, -56.73], sketch001)
       )
     })
 
-    await test.step('double check that circle three point can be unequiped', async () => {
-      // this was tested implicitly for other tools, but not for circle three point since it's last
+    await test.step('create three-point arcs in a row without an unequip', async () => {
+      // Define points for the first three-point arc
+      const [arc1Point1, arc1Point1Move] = scene.makeMouseHelpers(700, 397)
+      const [arc1Point2, arc1Point2Move] = scene.makeMouseHelpers(724, 346)
+      const [arc1Point3, arc1Point3Move] = scene.makeMouseHelpers(785, 415)
+
+      // Define points for the second three-point arc
+      const [arc2Point1, arc2Point1Move] = scene.makeMouseHelpers(792, 225)
+      const [arc2Point2, arc2Point2Move] = scene.makeMouseHelpers(820, 207)
+      const [arc2Point3, arc2Point3Move] = scene.makeMouseHelpers(905, 229)
+
+      // Select the three-point arc tool
+      await toolbar.selectThreePointArc()
+
+      // Create the first three-point arc
+      await arc1Point1Move()
+      await arc1Point1()
+      await page.waitForTimeout(300)
+      await arc1Point2Move()
+      await arc1Point2()
+      await page.waitForTimeout(300)
+      await arc1Point3Move()
+      await arc1Point3()
+      await page.waitForTimeout(300)
+
+      // Verify the first three-point arc was created correctly
+      await editor.expectEditor.toContain(
+        `profile011 = startProfileAt([13.56, -9.97], sketch001)
+  |> arcTo({
+       interior = [15.19, -6.51],
+       end = [19.33, -11.19]
+     }, %)`,
+        { shouldNormalise: true }
+      )
+
+      // Create the second three-point arc
+      await arc2Point1Move()
+      await arc2Point1()
+      await page.waitForTimeout(300)
+      await arc2Point2Move()
+      await arc2Point2()
+      await page.waitForTimeout(300)
+      await arc2Point3Move()
+      await arc2Point3()
+      await page.waitForTimeout(300)
+
+      // Verify the second three-point arc was created correctly
+      await editor.expectEditor.toContain(
+        `  |> arcTo({
+       interior = [19.8, 1.7],
+       end = [21.7, 2.92]
+     }, %)
+  |> arcTo({
+       interior = [27.47, 1.42],
+       end = [27.57, 1.52]
+     }, %)`,
+        { shouldNormalise: true }
+      )
+    })
+
+    await test.step('double check that three-point arc can be unequipped', async () => {
+      // this was tested implicitly for other tools, but not for three-point arc since it's last
       await page.waitForTimeout(300)
       await expect
         .poll(async () => {
@@ -2085,7 +2318,7 @@ profile003 = circle(sketch001, center = [6.92, -4.2], radius = 3.16)
   test(
     'can enter sketch when there is an extrude',
     { tag: ['@skipWin'] },
-    async ({ homePage, scene, toolbar, page }) => {
+    async ({ homePage, scene, toolbar, page, cmdBar }) => {
       await page.addInitScript(async () => {
         localStorage.setItem(
           'persistCode',
@@ -2122,6 +2355,8 @@ extrude001 = extrude(profile003, length = 5)
 
       await page.setBodyDimensions({ width: 1000, height: 500 })
       await homePage.goToModelingScene()
+      await scene.connectionEstablished()
+      await scene.settled(cmdBar)
       await expect(
         page.getByRole('button', { name: 'Start Sketch' })
       ).not.toBeDisabled()
@@ -2134,9 +2369,11 @@ extrude001 = extrude(profile003, length = 5)
       await page.waitForTimeout(600)
 
       await test.step('check the sketch is still drawn properly', async () => {
-        await scene.expectPixelColor([255, 255, 255], { x: 596, y: 165 }, 15)
-        await scene.expectPixelColor([255, 255, 255], { x: 641, y: 220 }, 15)
-        await scene.expectPixelColor([255, 255, 255], { x: 763, y: 214 }, 15)
+        await Promise.all([
+          scene.expectPixelColor(TEST_COLORS.WHITE, { x: 596, y: 165 }, 15),
+          scene.expectPixelColor(TEST_COLORS.WHITE, { x: 641, y: 220 }, 15),
+          scene.expectPixelColor(TEST_COLORS.WHITE, { x: 763, y: 214 }, 15),
+        ])
       })
     }
   )
@@ -2293,7 +2530,7 @@ extrude001 = extrude(thePart, length = 75)
   test(
     'Can enter sketch on sketch of wall and cap for segment, solid2d, extrude-wall, extrude-cap selections',
     { tag: ['@skipWin'] },
-    async ({ homePage, scene, toolbar, editor, page }) => {
+    async ({ homePage, scene, toolbar, editor, page, cmdBar }) => {
       // TODO this test should include a test for selecting revolve walls and caps
 
       await page.addInitScript(async () => {
@@ -2378,6 +2615,8 @@ extrude003 = extrude(profile011, length = 2.5)
 
       await page.setBodyDimensions({ width: 1000, height: 500 })
       await homePage.goToModelingScene()
+      await scene.connectionEstablished()
+      await scene.settled(cmdBar)
       await expect(
         page.getByRole('button', { name: 'Start Sketch' })
       ).not.toBeDisabled()
@@ -2440,39 +2679,22 @@ extrude003 = extrude(profile011, length = 2.5)
 
       const verifyWallProfilesAreDrawn = async () =>
         test.step('verify wall profiles are drawn', async () => {
-          // open polygon
-          await scene.expectPixelColor(
-            TEST_COLORS.WHITE,
-            { x: 599, y: 168 },
-            15
-          )
-          // closed polygon
-          await scene.expectPixelColor(
-            TEST_COLORS.WHITE,
-            { x: 656, y: 171 },
-            15
-          )
-          // revolved profile
-          await scene.expectPixelColor(
-            TEST_COLORS.WHITE,
-            { x: 655, y: 264 },
-            15
-          )
-          // extruded profile
-          await scene.expectPixelColor(
-            TEST_COLORS.WHITE,
-            { x: 808, y: 396 },
-            15
-          )
-          // circle
-          await scene.expectPixelColor(
-            [
-              TEST_COLORS.WHITE,
-              TEST_COLORS.BLUE, // When entering via the circle, it's selected and therefore blue
-            ],
-            { x: 742, y: 386 },
-            15
-          )
+          await Promise.all([
+            // open polygon
+            scene.expectPixelColor(TEST_COLORS.WHITE, { x: 599, y: 168 }, 15),
+            // closed polygon
+            scene.expectPixelColor(TEST_COLORS.WHITE, { x: 656, y: 171 }, 15),
+            // revolved profile
+            scene.expectPixelColor(TEST_COLORS.WHITE, { x: 655, y: 264 }, 15),
+            // extruded profile
+            scene.expectPixelColor(TEST_COLORS.WHITE, { x: 808, y: 396 }, 15),
+            // circle (When entering via the circle, it's selected and therefore blue)
+            scene.expectPixelColor(
+              [TEST_COLORS.WHITE, TEST_COLORS.BLUE],
+              { x: 742, y: 386 },
+              15
+            ),
+          ])
         })
 
       const verifyCapProfilesAreDrawn = async () =>

e2e/playwright/snapshot-tests.spec.ts

@@ -410,9 +410,9 @@ test.describe(
 test(
   'Draft segments should look right',
   { tag: '@snapshot' },
-  async ({ page, context, scene, cmdBar }) => {
+  async ({ page, scene, toolbar }) => {
     // FIXME: Skip on macos its being weird.
-    test.skip(process.platform === 'darwin', 'Skip on macos')
+    // test.skip(process.platform === 'darwin', 'Skip on macos')
 
     const u = await getUtils(page)
     await page.setViewportSize({ width: 1200, height: 500 })
@@ -421,6 +421,23 @@ test(
 
     await scene.connectionEstablished()
 
+    const startXPx = 600
+    const [endOfTangentClk, endOfTangentMv] = scene.makeMouseHelpers(
+      startXPx + PUR * 30,
+      500 - PUR * 20,
+      { steps: 10 }
+    )
+    const [threePointArcMidPointClk, threePointArcMidPointMv] =
+      scene.makeMouseHelpers(800, 250, { steps: 10 })
+    const [threePointArcEndPointClk, threePointArcEndPointMv] =
+      scene.makeMouseHelpers(750, 285, { steps: 10 })
+    const [arcCenterClk, arcCenterMv] = scene.makeMouseHelpers(750, 210, {
+      steps: 10,
+    })
+    const [arcEndClk, arcEndMv] = scene.makeMouseHelpers(750, 150, {
+      steps: 10,
+    })
+
     // click on "Start Sketch" button
     await u.doAndWaitForImageDiff(
       () => page.getByRole('button', { name: 'Start Sketch' }).click(),
@@ -435,7 +452,6 @@ test(
 
     await page.waitForTimeout(700) // TODO detect animation ending, or disable animation
 
-    const startXPx = 600
     await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
     code += `profile001 = startProfileAt([7.19, -9.7], sketch001)`
     await expect(page.locator('.cm-content')).toHaveText(code)
@@ -471,12 +487,52 @@ test(
     await page.mouse.move(813, 392, { steps: 10 })
     await page.waitForTimeout(500)
 
-    await page.mouse.move(startXPx + PUR * 30, 500 - PUR * 20, { steps: 10 })
+    await endOfTangentMv()
 
     await expect(page).toHaveScreenshot({
       maxDiffPixels: 100,
       mask: [page.getByTestId('model-state-indicator')],
     })
+    await endOfTangentClk()
+
+    await toolbar.selectThreePointArc()
+    await page.waitForTimeout(500)
+    await endOfTangentClk()
+    await threePointArcMidPointMv()
+    await expect(page).toHaveScreenshot({
+      maxDiffPixels: 100,
+      mask: [page.getByTestId('model-state-indicator')],
+    })
+    await threePointArcMidPointClk()
+    await page.waitForTimeout(100)
+
+    await threePointArcEndPointMv()
+    await page.waitForTimeout(500)
+    await expect(page).toHaveScreenshot({
+      maxDiffPixels: 100,
+      mask: [page.getByTestId('model-state-indicator')],
+    })
+
+    await threePointArcEndPointClk()
+    await page.waitForTimeout(100)
+
+    await toolbar.selectArc()
+    await page.waitForTimeout(100)
+
+    // continue the profile
+    await threePointArcEndPointClk()
+    await page.waitForTimeout(100)
+    await arcCenterMv()
+    await page.waitForTimeout(500)
+    await arcCenterClk()
+
+    await arcEndMv()
+    await page.waitForTimeout(500)
+    await expect(page).toHaveScreenshot({
+      maxDiffPixels: 100,
+      mask: [page.getByTestId('model-state-indicator')],
+    })
+    await arcEndClk()
   }
 )
 

e2e/playwright/snapshots/prompt-to-edit/prompt-to-edit-snapshot-tests-spec-ts--edit-with-ai-example-snapshots--change-colour.snap.json

@@ -0,0 +1,33 @@
+{
+  "original_source_code": "sketch001 = startSketchOn('XZ')\nprofile001 = startProfileAt([57.81, 250.51], sketch001)\n  |> line(end = [121.13, 56.63], tag = $seg02)\n  |> line(end = [83.37, -34.61], tag = $seg01)\n  |> line(end = [19.66, -116.4])\n  |> line(end = [-221.8, -41.69])\n  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n  |> close()\nextrude001 = extrude(profile001, length = 200)\nsketch002 = startSketchOn('XZ')\n  |> startProfileAt([-73.64, -42.89], %)\n  |> xLine(length = 173.71)\n  |> line(end = [-22.12, -94.4])\n  |> xLine(length = -156.98)\n  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n  |> close()\nextrude002 = extrude(sketch002, length = 50)\nsketch003 = startSketchOn('XY')\n  |> startProfileAt([52.92, 157.81], %)\n  |> angledLine([0, 176.4], %, $rectangleSegmentA001)\n  |> angledLine([\n       segAng(rectangleSegmentA001) - 90,\n       53.4\n     ], %, $rectangleSegmentB001)\n  |> angledLine([\n       segAng(rectangleSegmentA001),\n       -segLen(rectangleSegmentA001)\n     ], %, $rectangleSegmentC001)\n  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])\n  |> close()\nextrude003 = extrude(sketch003, length = 20)\n",
+  "prompt": "make this neon green please, use #39FF14",
+  "source_ranges": [
+    {
+      "prompt": "The users main selection is the end cap of a general-sweep (that is an extrusion, revolve, sweep or loft).\nThe source range most likely refers to \"startProfileAt\" simply because this is the start of the profile that was swept.\nIf you need to operate on this cap, for example for sketching on the face, you can use the special string END i.e. `startSketchOn(someSweepVariable, END)`\nWhen they made this selection they main have intended this surface directly or meant something more general like the sweep body.\nSee later source ranges for more context.",
+      "range": {
+        "start": {
+          "line": 11,
+          "column": 5
+        },
+        "end": {
+          "line": 11,
+          "column": 40
+        }
+      }
+    },
+    {
+      "prompt": "This is the sweep's source range from the user's main selection of the end cap.",
+      "range": {
+        "start": {
+          "line": 17,
+          "column": 13
+        },
+        "end": {
+          "line": 17,
+          "column": 44
+        }
+      }
+    }
+  ],
+  "kcl_version": "0.2.50"
+}

e2e/playwright/testing-segment-overlays.spec.ts

@@ -159,7 +159,6 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
           const unconstrainedLocator = page.locator(
             `[data-constraint-type="${constraintType}"][data-is-constrained="false"]`
           )
-          await expect(unconstrainedLocator).toBeVisible()
           await unconstrainedLocator.hover()
           await expect(
             await page.getByTestId('constraint-symbol-popover').count()
@@ -274,8 +273,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
 
         let ang = 0
 
-        const line = await u.getBoundingBox(`[data-overlay-index="${0}"]`)
-        ang = await u.getAngle(`[data-overlay-index="${0}"]`)
+        const line = await u.getBoundingBox('[data-overlay-index="0"]')
+        ang = await u.getAngle('[data-overlay-index="0"]')
         console.log('line1', line, ang)
         await clickConstrained({
           hoverPos: { x: line.x, y: line.y },
@@ -297,8 +296,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
           locator: '[data-overlay-index="0"]',
         })
 
-        const angledLine = await u.getBoundingBox(`[data-overlay-index="1"]`)
-        ang = await u.getAngle(`[data-overlay-index="1"]`)
+        const angledLine = await u.getBoundingBox('[data-overlay-index="1"]')
+        ang = await u.getAngle('[data-overlay-index="1"]')
         console.log('angledLine1')
         await clickConstrained({
           hoverPos: { x: angledLine.x, y: angledLine.y },
@@ -327,8 +326,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         await page.mouse.move(700, 250)
         await page.waitForTimeout(100)
 
-        let lineTo = await u.getBoundingBox(`[data-overlay-index="2"]`)
-        ang = await u.getAngle(`[data-overlay-index="2"]`)
+        let lineTo = await u.getBoundingBox('[data-overlay-index="2"]')
+        ang = await u.getAngle('[data-overlay-index="2"]')
         console.log('lineTo1')
         await clickConstrained({
           hoverPos: { x: lineTo.x, y: lineTo.y },
@@ -353,8 +352,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
           locator: '[data-overlay-toolbar-index="2"]',
         })
 
-        const xLineTo = await u.getBoundingBox(`[data-overlay-index="3"]`)
-        ang = await u.getAngle(`[data-overlay-index="3"]`)
+        const xLineTo = await u.getBoundingBox('[data-overlay-index="3"]')
+        ang = await u.getAngle('[data-overlay-index="3"]')
         console.log('xlineTo1')
         await clickConstrained({
           hoverPos: { x: xLineTo.x, y: xLineTo.y },
@@ -419,8 +418,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
 
           let ang = 0
 
-          const yLineTo = await u.getBoundingBox(`[data-overlay-index="4"]`)
-          ang = await u.getAngle(`[data-overlay-index="4"]`)
+          const yLineTo = await u.getBoundingBox('[data-overlay-index="4"]')
+          ang = await u.getAngle('[data-overlay-index="4"]')
           console.log('ylineTo1')
           await clickUnconstrained({
             hoverPos: { x: yLineTo.x, y: yLineTo.y - 200 },
@@ -432,8 +431,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
             locator: '[data-overlay-toolbar-index="4"]',
           })
 
-          const xLine = await u.getBoundingBox(`[data-overlay-index="5"]`)
-          ang = await u.getAngle(`[data-overlay-index="5"]`)
+          const xLine = await u.getBoundingBox('[data-overlay-index="5"]')
+          ang = await u.getAngle('[data-overlay-index="5"]')
           console.log('xline')
           await clickUnconstrained({
             hoverPos: { x: xLine.x, y: xLine.y },
@@ -501,8 +500,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
 
         let ang = 0
 
-        const yLine = await u.getBoundingBox(`[data-overlay-index="6"]`)
-        ang = await u.getAngle(`[data-overlay-index="6"]`)
+        const yLine = await u.getBoundingBox('[data-overlay-index="6"]')
+        ang = await u.getAngle('[data-overlay-index="6"]')
         console.log('yline1')
         await clickConstrained({
           hoverPos: { x: yLine.x, y: yLine.y },
@@ -515,9 +514,9 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         })
 
         const angledLineOfXLength = await u.getBoundingBox(
-          `[data-overlay-index="7"]`
+          '[data-overlay-index="7"]'
         )
-        ang = await u.getAngle(`[data-overlay-index="7"]`)
+        ang = await u.getAngle('[data-overlay-index="7"]')
         console.log('angledLineOfXLength1')
         await clickConstrained({
           hoverPos: { x: angledLineOfXLength.x, y: angledLineOfXLength.y },
@@ -547,9 +546,9 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         })
 
         const angledLineOfYLength = await u.getBoundingBox(
-          `[data-overlay-index="8"]`
+          '[data-overlay-index="8"]'
         )
-        ang = await u.getAngle(`[data-overlay-index="8"]`)
+        ang = await u.getAngle('[data-overlay-index="8"]')
         console.log('angledLineOfYLength1')
         await clickUnconstrained({
           hoverPos: { x: angledLineOfYLength.x, y: angledLineOfYLength.y },
@@ -632,8 +631,8 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
 
         let ang = 0
 
-        const angledLineToX = await u.getBoundingBox(`[data-overlay-index="9"]`)
-        ang = await u.getAngle(`[data-overlay-index="9"]`)
+        const angledLineToX = await u.getBoundingBox('[data-overlay-index="9"]')
+        ang = await u.getAngle('[data-overlay-index="9"]')
         console.log('angledLineToX')
         await clickConstrained({
           hoverPos: { x: angledLineToX.x, y: angledLineToX.y },
@@ -659,9 +658,9 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         })
 
         const angledLineToY = await u.getBoundingBox(
-          `[data-overlay-index="10"]`
+          '[data-overlay-index="10"]'
         )
-        ang = await u.getAngle(`[data-overlay-index="10"]`)
+        ang = await u.getAngle('[data-overlay-index="10"]')
         console.log('angledLineToY')
         await clickUnconstrained({
           hoverPos: { x: angledLineToY.x, y: angledLineToY.y },
@@ -689,9 +688,9 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         })
 
         const angledLineThatIntersects = await u.getBoundingBox(
-          `[data-overlay-index="11"]`
+          '[data-overlay-index="11"]'
         )
-        ang = await u.getAngle(`[data-overlay-index="11"]`)
+        ang = await u.getAngle('[data-overlay-index="11"]')
         console.log('angledLineThatIntersects')
         await clickUnconstrained({
           hoverPos: {
@@ -821,6 +820,138 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
           locator: '[data-overlay-toolbar-index="12"]',
         })
       })
+      test('for segment [arcTo]', async ({
+        page,
+        editor,
+        homePage,
+        scene,
+        cmdBar,
+      }) => {
+        await page.addInitScript(async () => {
+          localStorage.setItem(
+            'persistCode',
+            `sketch001 = startSketchOn('XZ')
+profile001 = startProfileAt([56.37, 120.33], sketch001)
+  |> line(end = [162.86, 106.48])
+  |> arcTo({
+       interior = [360.16, 231.76],
+       end = [391.48, 131.54]
+     }, %)
+  |> yLine(-131.54, %)
+  |> arc({
+       radius = 126.46,
+       angleStart = 33.53,
+       angleEnd = -141.07
+     }, %)
+`
+          )
+          localStorage.setItem('disableAxis', 'true')
+        })
+        const u = await getUtils(page)
+        await page.setBodyDimensions({ width: 1200, height: 500 })
+
+        await homePage.goToModelingScene()
+        await scene.connectionEstablished()
+        await scene.settled(cmdBar)
+
+        // wait for execution done
+
+        await page.getByText('line(end = [162.86, 106.48])').click()
+        await page.waitForTimeout(100)
+        await page.getByRole('button', { name: 'Edit Sketch' }).click()
+        await page.waitForTimeout(500)
+
+        await expect(page.getByTestId('segment-overlay')).toHaveCount(5)
+
+        const clickUnconstrained = _clickUnconstrained(page, editor)
+        const clickConstrained = _clickConstrained(page, editor)
+
+        const arcTo = await u.getBoundingBox('[data-overlay-index="1"]')
+        let ang = await u.getAngle('[data-overlay-index="1"]')
+        console.log('arcTo interior x')
+        await clickUnconstrained({
+          hoverPos: { x: arcTo.x, y: arcTo.y },
+          constraintType: 'xAbsolute',
+          expectBeforeUnconstrained: `arcTo({
+       interior = [360.16, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectAfterUnconstrained: `arcTo({
+       interior = [360.16, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectFinal: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          ang: ang,
+          steps: 6,
+          locator: '[data-overlay-toolbar-index="1"]',
+        })
+
+        console.log('arcTo interior y')
+        await clickUnconstrained({
+          hoverPos: { x: arcTo.x, y: arcTo.y },
+          constraintType: 'yAbsolute',
+          expectBeforeUnconstrained: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectAfterUnconstrained: `arcTo({
+       interior = [xAbs001, yAbs001],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectFinal: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          ang: ang,
+          steps: 10,
+          locator: '[data-overlay-toolbar-index="1"]',
+        })
+
+        console.log('arcTo end x')
+        await clickConstrained({
+          hoverPos: { x: arcTo.x, y: arcTo.y },
+          constraintType: 'xAbsolute',
+          expectBeforeUnconstrained: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectAfterUnconstrained: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [391.48, 131.54]
+     }, %)`,
+          expectFinal: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [xAbs002, 131.54]
+     }, %)`,
+          ang: ang + 180,
+          steps: 6,
+          locator: '[data-overlay-toolbar-index="1"]',
+        })
+
+        console.log('arcTo end y')
+        await clickUnconstrained({
+          hoverPos: { x: arcTo.x, y: arcTo.y },
+          constraintType: 'yAbsolute',
+          expectBeforeUnconstrained: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [xAbs002, 131.54]
+     }, %)`,
+          expectAfterUnconstrained: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [xAbs002, yAbs002]
+     }, %)`,
+          expectFinal: `arcTo({
+       interior = [xAbs001, 231.76],
+       end = [xAbs002, 131.54]
+     }, %)`,
+          ang: ang + 180,
+          steps: 10,
+          locator: '[data-overlay-toolbar-index="1"]',
+        })
+      })
       test('for segment [circle]', async ({ page, editor, homePage }) => {
         await page.addInitScript(async () => {
           localStorage.setItem(
@@ -928,36 +1059,55 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
           shouldNormalise: true,
         })
 
-        await page.locator(`[data-stdlib-fn-name="${stdLibFnName}"]`).click()
+        await page
+          .locator(`[data-stdlib-fn-name="${stdLibFnName}"]`)
+          .first()
+          .click()
         await page.getByText('Delete Segment').click()
 
         await editor.expectEditor.not.toContain(codeToBeDeleted, {
           shouldNormalise: true,
         })
       }
-    test('all segment types', async ({ page, editor, homePage }) => {
+    test('all segment types', async ({
+      page,
+      editor,
+      homePage,
+      scene,
+      cmdBar,
+    }) => {
       await page.addInitScript(async () => {
         localStorage.setItem(
           'persistCode',
           `part001 = startSketchOn('XZ')
-      |> startProfileAt([0, 0], %)
-      |> line(end = [0.5, -14 + 0])
-      |> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
-      |> line(endAbsolute = [33, 11.5 + 0])
-      |> xLine(endAbsolute = 9 - 5)
-      |> yLine(endAbsolute = -10.77, tag = $a)
-      |> xLine(length = 26.04)
-      |> yLine(length = 21.14 + 0)
-      |> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
-      |> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
-      |> angledLineToX({ angle = 3 + 0, to = 26 }, %)
-      |> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
-      |> angledLineThatIntersects({
-     angle = 4.14,
-     intersectTag = a,
-     offset = 9
-         }, %)
-      |> tangentialArcTo([3.14 + 13, 1.14], %)
+  |>startProfileAt([0, 0], %)
+  |> line(end = [0.5, -14 + 0])
+  |> angledLine({ angle = 3 + 0, length = 32 + 0 }, %)
+  |> line(endAbsolute = [33, 11.5 + 0])
+  |> xLine(endAbsolute = 9 - 5)
+  |> yLine(endAbsolute = -10.77, tag = $a)
+  |> xLine(length = 26.04)
+  |> yLine(length = 21.14 + 0)
+  |> angledLineOfXLength({ angle = 181 + 0, length = 23.14 }, %)
+  |> angledLineOfYLength({ angle = -91, length = 19 + 0 }, %)
+  |> angledLineToX({ angle = 3 + 0, to = 26 }, %)
+  |> angledLineToY({ angle = 89, to = 9.14 + 0 }, %)
+  |> angledLineThatIntersects({
+       angle = 4.14,
+       intersectTag = a,
+       offset = 9
+     }, %)
+  |> tangentialArcTo([3.14 + 13, 1.14], %)
+  |> arcTo({
+       interior = [16.25, 5.12],
+       end = [21.61, 4.15]
+     }, %)
+  |> arc({
+       radius = 9.03,
+       angleStart = 40.27,
+       angleEnd = -38.05
+     }, %)
+
       `
         )
         localStorage.setItem('disableAxis', 'true')
@@ -966,27 +1116,55 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       await page.setBodyDimensions({ width: 1200, height: 500 })
 
       await homePage.goToModelingScene()
+      await scene.connectionEstablished()
+      await scene.settled(cmdBar)
       await u.waitForPageLoad()
 
-      // wait for execution done
-      await u.openDebugPanel()
-      await u.expectCmdLog('[data-message-type="execution-done"]')
-      await u.closeDebugPanel()
-
       await page.getByText('xLine(endAbsolute = 9 - 5)').click()
       await page.waitForTimeout(100)
       await page.getByRole('button', { name: 'Edit Sketch' }).click()
       await page.waitForTimeout(500)
 
-      await expect(page.getByTestId('segment-overlay')).toHaveCount(13)
+      await expect(page.getByTestId('segment-overlay')).toHaveCount(16)
       const deleteSegmentSequence = _deleteSegmentSequence(page, editor)
 
       let segmentToDelete
 
       const getOverlayByIndex = (index: number) =>
         u.getBoundingBox(`[data-overlay-index="${index}"]`)
+
+      segmentToDelete = await getOverlayByIndex(14)
+      let ang = await u.getAngle('[data-overlay-index="14"]')
+
+      await editor.scrollToText('angleEnd')
+
+      await deleteSegmentSequence({
+        hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
+        codeToBeDeleted: `arc({
+       radius = 9.03,
+       angleStart = 40.27,
+       angleEnd = -38.05
+     }, %)`,
+        stdLibFnName: 'arc',
+        ang: ang + 180,
+        steps: 6,
+        locator: '[data-overlay-toolbar-index="14"]',
+      })
+      segmentToDelete = await getOverlayByIndex(13)
+      ang = await u.getAngle('[data-overlay-index="13"]')
+      await deleteSegmentSequence({
+        hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
+        codeToBeDeleted: `arcTo({
+       interior = [16.25, 5.12],
+       end = [21.61, 4.15]
+     }, %)`,
+        stdLibFnName: 'arcTo',
+        ang: ang,
+        steps: 6,
+        locator: '[data-overlay-toolbar-index="13"]',
+      })
       segmentToDelete = await getOverlayByIndex(12)
-      let ang = await u.getAngle(`[data-overlay-index="${12}"]`)
+      ang = await u.getAngle('[data-overlay-index="12"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'tangentialArcTo([3.14 + 13, 1.14], %)',
@@ -997,7 +1175,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(11)
-      ang = await u.getAngle(`[data-overlay-index="${11}"]`)
+      ang = await u.getAngle('[data-overlay-index="11"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: `angledLineThatIntersects({
@@ -1012,7 +1190,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(10)
-      ang = await u.getAngle(`[data-overlay-index="${10}"]`)
+      ang = await u.getAngle('[data-overlay-index="10"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'angledLineToY({ angle = 89, to = 9.14 + 0 }, %)',
@@ -1022,7 +1200,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(9)
-      ang = await u.getAngle(`[data-overlay-index="${9}"]`)
+      ang = await u.getAngle('[data-overlay-index="9"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'angledLineToX({ angle = 3 + 0, to = 26 }, %)',
@@ -1032,7 +1210,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(8)
-      ang = await u.getAngle(`[data-overlay-index="${8}"]`)
+      ang = await u.getAngle('[data-overlay-index="8"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted:
@@ -1043,7 +1221,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(7)
-      ang = await u.getAngle(`[data-overlay-index="${7}"]`)
+      ang = await u.getAngle('[data-overlay-index="7"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted:
@@ -1054,7 +1232,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(6)
-      ang = await u.getAngle(`[data-overlay-index="${6}"]`)
+      ang = await u.getAngle('[data-overlay-index="6"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'yLine(length = 21.14 + 0)',
@@ -1064,7 +1242,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(5)
-      ang = await u.getAngle(`[data-overlay-index="${5}"]`)
+      ang = await u.getAngle('[data-overlay-index="5"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'xLine(length = 26.04)',
@@ -1074,7 +1252,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(4)
-      ang = await u.getAngle(`[data-overlay-index="${4}"]`)
+      ang = await u.getAngle('[data-overlay-index="4"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'yLine(endAbsolute = -10.77, tag = $a)',
@@ -1084,7 +1262,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(3)
-      ang = await u.getAngle(`[data-overlay-index="${3}"]`)
+      ang = await u.getAngle('[data-overlay-index="3"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'xLine(endAbsolute = 9 - 5)',
@@ -1094,7 +1272,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(2)
-      ang = await u.getAngle(`[data-overlay-index="${2}"]`)
+      ang = await u.getAngle('[data-overlay-index="2"]')
       await expect(page.getByText('Added variable')).not.toBeVisible()
 
       const hoverPos = { x: segmentToDelete.x, y: segmentToDelete.y }
@@ -1127,7 +1305,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(1)
-      ang = await u.getAngle(`[data-overlay-index="${1}"]`)
+      ang = await u.getAngle('[data-overlay-index="1"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'angledLine({ angle = 3 + 0, length = 32 + 0 }, %)',
@@ -1137,7 +1315,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
       })
 
       segmentToDelete = await getOverlayByIndex(0)
-      ang = await u.getAngle(`[data-overlay-index="${0}"]`)
+      ang = await u.getAngle('[data-overlay-index="0"]')
       await deleteSegmentSequence({
         hoverPos: { x: segmentToDelete.x, y: segmentToDelete.y },
         codeToBeDeleted: 'line(end = [0.5, -14 + 0])',
@@ -1366,7 +1544,7 @@ test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
         await expect(page.getByText('Added variable')).not.toBeVisible()
 
         const hoverPos = await u.getBoundingBox(`[data-overlay-index="0"]`)
-        let ang = await u.getAngle(`[data-overlay-index="${0}"]`)
+        let ang = await u.getAngle('[data-overlay-index="0"]')
         ang += 180
 
         await page.mouse.move(0, 0)

e2e/playwright/testing-selections.spec.ts

@@ -452,19 +452,15 @@ profile003 = startProfileAt([40.16, -120.48], sketch006)
     await page.waitForTimeout(200)
     await expect(u.codeLocator).not.toContainText(codeToBeDeletedSnippet)
   })
-  test('parent Solid should be select and deletable and uses custom planes to position children', async ({
-    page,
-    homePage,
-    scene,
-    cmdBar,
-    editor,
-  }) => {
-    test.setTimeout(90_000)
-    const u = await getUtils(page)
-    await page.addInitScript(async () => {
-      localStorage.setItem(
-        'persistCode',
-        `part001 = startSketchOn('XY')
+  test.fixme(
+    'parent Solid should be select and deletable and uses custom planes to position children',
+    async ({ page, homePage, scene, cmdBar, editor }) => {
+      test.setTimeout(90_000)
+      const u = await getUtils(page)
+      await page.addInitScript(async () => {
+        localStorage.setItem(
+          'persistCode',
+          `part001 = startSketchOn('XY')
 yo = startProfileAt([4.83, 12.56], part001)
   |> line(end = [15.1, 2.48])
   |> line(end = [3.15, -9.85], tag = $seg01)
@@ -495,34 +491,35 @@ profile001 = startProfileAt([7.49, 9.96], sketch001)
   |> close()
 
 `
+        )
+      }, KCL_DEFAULT_LENGTH)
+      await page.setBodyDimensions({ width: 1000, height: 500 })
+
+      await homePage.goToModelingScene()
+      await scene.settled(cmdBar)
+
+      const extrudeWall = { x: 575, y: 238 }
+
+      // DELETE with selection on face of parent
+      await page.mouse.click(extrudeWall.x, extrudeWall.y)
+      await page.waitForTimeout(100)
+      await expect(page.locator('.cm-activeLine')).toHaveText(
+        '|> line(end = [-15.17, -4.1])'
       )
-    }, KCL_DEFAULT_LENGTH)
-    await page.setBodyDimensions({ width: 1000, height: 500 })
+      await u.openAndClearDebugPanel()
+      await page.keyboard.press('Delete')
+      await u.expectCmdLog('[data-message-type="execution-done"]', 10_000)
+      await page.waitForTimeout(200)
 
-    await homePage.goToModelingScene()
-    await scene.settled(cmdBar)
-
-    const extrudeWall = { x: 575, y: 238 }
-
-    // DELETE with selection on face of parent
-    await page.mouse.click(extrudeWall.x, extrudeWall.y)
-    await page.waitForTimeout(100)
-    await expect(page.locator('.cm-activeLine')).toHaveText(
-      '|> line(end = [-15.17, -4.1])'
-    )
-    await u.openAndClearDebugPanel()
-    await page.keyboard.press('Delete')
-    await u.expectCmdLog('[data-message-type="execution-done"]', 10_000)
-    await page.waitForTimeout(200)
-
-    await editor.expectEditor.not.toContain(`yoo = extrude(yo, length = 4)`, {
-      shouldNormalise: true,
-    })
-    await editor.expectEditor.toContain(`startSketchOn({plane={origin`, {
-      shouldNormalise: true,
-    })
-    await editor.snapshot()
-  })
+      await editor.expectEditor.not.toContain(`yoo = extrude(yo, length = 4)`, {
+        shouldNormalise: true,
+      })
+      await editor.expectEditor.toContain(`startSketchOn({plane={origin`, {
+        shouldNormalise: true,
+      })
+      await editor.snapshot()
+    }
+  )
   test('Hovering over 3d features highlights code, clicking puts the cursor in the right place and sends selection id to engine', async ({
     page,
     homePage,

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

@@ -4,7 +4,7 @@ import { getUtils, createProject } from './test-utils'
 import { join } from 'path'
 import fs from 'fs'
 
-test.describe('Text-to-CAD tests', { tag: ['@skipWin'] }, () => {
+test.fixme('Text-to-CAD tests', { tag: ['@skipWin'] }, () => {
   test('basic lego happy case', async ({ page, homePage }) => {
     const u = await getUtils(page)
 

package.json

@@ -12,17 +12,17 @@
   "main": ".vite/build/main.js",
   "license": "MIT",
   "dependencies": {
-    "@codemirror/autocomplete": "^6.17.0",
+    "@codemirror/autocomplete": "^6.18.6",
     "@codemirror/commands": "^6.8.0",
-    "@codemirror/language": "^6.10.8",
+    "@codemirror/language": "^6.11.0",
     "@codemirror/lint": "^6.8.4",
     "@codemirror/search": "^6.5.10",
     "@codemirror/state": "^6.4.1",
     "@codemirror/theme-one-dark": "^6.1.2",
     "@csstools/postcss-oklab-function": "^4.0.7",
-    "@fortawesome/fontawesome-svg-core": "^6.5.2",
-    "@fortawesome/free-brands-svg-icons": "^6.5.2",
-    "@fortawesome/free-solid-svg-icons": "^6.4.2",
+    "@fortawesome/fontawesome-svg-core": "^6.7.2",
+    "@fortawesome/free-brands-svg-icons": "^6.7.2",
+    "@fortawesome/free-solid-svg-icons": "^6.7.2",
     "@fortawesome/react-fontawesome": "^0.2.0",
     "@headlessui/react": "^1.7.19",
     "@headlessui/tailwindcss": "^0.2.0",
@@ -35,35 +35,35 @@
     "@tweenjs/tween.js": "^23.1.1",
     "@xstate/inspect": "^0.8.0",
     "@xstate/react": "^4.1.1",
-    "bonjour-service": "^1.2.1",
+    "bonjour-service": "^1.3.0",
     "chokidar": "^4.0.1",
     "codemirror": "^6.0.1",
     "decamelize": "^6.0.0",
     "diff": "^7.0.0",
     "electron-updater": "^6.6.0",
-    "fuse.js": "^7.0.0",
+    "fuse.js": "^7.1.0",
     "html2canvas-pro": "^1.5.8",
     "isomorphic-fetch": "^3.0.0",
     "json-rpc-2.0": "^1.6.0",
     "jszip": "^3.10.1",
     "minimist": "^1.2.8",
     "openid-client": "^5.6.5",
-    "re-resizable": "^6.9.11",
+    "re-resizable": "^6.11.2",
     "react": "^18.3.1",
     "react-dom": "^18.2.0",
-    "react-hot-toast": "^2.4.1",
+    "react-hot-toast": "^2.5.2",
     "react-hotkeys-hook": "^4.6.1",
     "react-json-view": "^1.21.3",
     "react-modal": "^3.16.3",
     "react-modal-promise": "^1.0.2",
     "react-router-dom": "^6.28.0",
     "sketch-helpers": "^0.0.4",
-    "three": "^0.172.0",
+    "three": "^0.174.0",
     "ua-parser-js": "^1.0.37",
-    "uuid": "^11.0.2",
+    "uuid": "^11.1.0",
     "vscode-jsonrpc": "^8.2.1",
     "vscode-languageserver-protocol": "^3.17.5",
-    "vscode-uri": "^3.0.8",
+    "vscode-uri": "^3.1.0",
     "web-vitals": "^3.5.2",
     "xstate": "^5.19.2",
     "yargs": "^17.7.2"
@@ -93,11 +93,9 @@
     "fetch:wasm:windows": "./scripts/get-latest-wasm-bundle.ps1",
     "fetch:samples": "rm -rf public/kcl-samples* && curl -L -o public/kcl-samples.zip https://github.com/KittyCAD/kcl-samples/archive/refs/heads/achalmers/kw-args-xylineto.zip && unzip -o public/kcl-samples.zip -d public && mv public/kcl-samples-* public/kcl-samples",
     "build:wasm-dev": "yarn wasm-prep && (cd rust && wasm-pack build kcl-wasm-lib --dev --target web --out-dir pkg && cargo test -p kcl-lib export_bindings) && yarn isomorphic-copy-wasm && yarn fmt",
-    "build:wasm:nocopy": "yarn wasm-prep && cd rust && RUSTFLAGS='--cfg getrandom_backend=\"wasm_js\"' wasm-pack build kcl-wasm-lib --release  --target web --out-dir pkg && cargo test -p kcl-lib export_bindings",
-    "build:wasm": "yarn build:wasm:nocopy && cp rust/kcl-wasm-lib/pkg/kcl_wasm_lib_bg.wasm public && yarn fmt",
-    "build:wasm:windows": "yarn install:wasm-pack:cargo && yarn build:wasm:nocopy && ./scripts/copy-wasm.ps1  && yarn fmt",
+    "build:wasm": "./scripts/build-wasm.sh",
+    "build:wasm:windows": "./scripts/build-wasm.ps1",
     "remove-importmeta": "sed -i 's/import.meta.url/window.location.origin/g' \"./rust/kcl-wasm-lib/pkg/kcl_wasm_lib.js\"; sed -i '' 's/import.meta.url/window.location.origin/g' \"./rust/kcl-wasm-lib/pkg/kcl_wasm_lib.js\" || echo \"sed for both mac and linux\"",
-    "wasm-prep": "rimraf rust/kcl-wasm-lib/pkg && mkdirp rust/kcl-wasm-lib/pkg && rimraf rust/kcl-lib/bindings",
     "lint-fix": "eslint --fix --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src rust/kcl-language-server/client/src",
     "lint": "eslint --max-warnings 0 --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src rust/kcl-language-server/client/src",
     "files:set-version": "echo \"$(jq --arg v \"$VERSION\" '.version=$v' package.json --indent 2)\" > package.json",
@@ -153,16 +151,16 @@
   },
   "devDependencies": {
     "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
-    "@babel/preset-env": "^7.25.4",
-    "@electron-forge/cli": "^7.6.1",
-    "@electron-forge/plugin-fuses": "^7.6.1",
-    "@electron-forge/plugin-vite": "^7.6.1",
+    "@babel/preset-env": "^7.26.9",
+    "@electron-forge/cli": "^7.7.0",
+    "@electron-forge/plugin-fuses": "^7.7.0",
+    "@electron-forge/plugin-vite": "^7.7.0",
     "@electron/fuses": "^1.8.0",
     "@electron/notarize": "^2.5.0",
     "@iarna/toml": "^2.2.5",
     "@lezer/generator": "^1.7.2",
     "@nabla/vite-plugin-eslint": "^2.0.5",
-    "@playwright/test": "^1.49.0",
+    "@playwright/test": "^1.51.0",
     "@testing-library/jest-dom": "^5.14.1",
     "@testing-library/react": "^15.0.2",
     "@types/diff": "^7.0.1",
@@ -176,7 +174,7 @@
     "@types/react": "^18.3.4",
     "@types/react-dom": "^18.3.1",
     "@types/react-modal": "^3.16.3",
-    "@types/three": "^0.172.0",
+    "@types/three": "^0.174.0",
     "@types/ua-parser-js": "^0.7.39",
     "@types/uuid": "^9.0.8",
     "@types/wicg-file-system-access": "^2023.10.5",
@@ -189,11 +187,11 @@
     "electron-builder": "^26.0.6",
     "eslint": "^8.0.1",
     "eslint-plugin-css-modules": "^2.12.0",
-    "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-jest": "^28.10.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jest": "^28.11.0",
     "eslint-plugin-jsx-a11y": "^6.10.2",
     "eslint-plugin-react": "^7.37.4",
-    "eslint-plugin-react-hooks": "^5.1.0",
+    "eslint-plugin-react-hooks": "^5.2.0",
     "eslint-plugin-react-perf": "^3.3.3",
     "eslint-plugin-suggest-no-throw": "^1.0.0",
     "eslint-plugin-testing-library": "^7.1.1",
@@ -210,8 +208,8 @@
     "setimmediate": "^1.0.5",
     "tailwindcss": "^3.4.17",
     "ts-node": "^10.0.0",
-    "typescript": "^5.7.3",
-    "typescript-eslint": "^8.23.0",
+    "typescript": "^5.8.2",
+    "typescript-eslint": "^8.26.1",
     "vite": "^5.4.12",
     "vite-plugin-package-version": "^1.1.0",
     "vite-tsconfig-paths": "^4.3.2",

packages/codemirror-lsp-client/package.json

@@ -19,14 +19,14 @@
   "private": false,
   "dependencies": {
     "@codemirror/autocomplete": "6.18.6",
-    "@codemirror/language": "^6.10.2",
-    "@codemirror/state": "^6.4.1",
+    "@codemirror/language": "^6.11.0",
+    "@codemirror/state": "^6.5.2",
     "@lezer/highlight": "^1.2.0",
     "@ts-stack/markdown": "^1.5.0",
     "json-rpc-2.0": "^1.7.0",
-    "typescript": "^5.7.2",
+    "typescript": "^5.8.2",
     "vscode-languageserver-protocol": "^3.17.5",
-    "vscode-uri": "^3.0.8"
+    "vscode-uri": "^3.1.0"
   },
   "devDependencies": {
     "@types/node": "^22.13.9",

packages/codemirror-lsp-client/yarn.lock

@@ -12,10 +12,10 @@
     "@codemirror/view" "^6.17.0"
     "@lezer/common" "^1.0.0"
 
-"@codemirror/language@^6.0.0", "@codemirror/language@^6.10.2":
-  version "6.10.2"
-  resolved "https://registry.yarnpkg.com/@codemirror/language/-/language-6.10.2.tgz#4056dc219619627ffe995832eeb09cea6060be61"
-  integrity sha512-kgbTYTo0Au6dCSc/TFy7fK3fpJmgHDv1sG1KNQKJXVi+xBTEeBPY/M30YXiU6mMXeH+YIDLsbrT4ZwNRdtF+SA==
+"@codemirror/language@^6.0.0", "@codemirror/language@^6.11.0":
+  version "6.11.0"
+  resolved "https://registry.yarnpkg.com/@codemirror/language/-/language-6.11.0.tgz#5ae90972601497f4575f30811519d720bf7232c9"
+  integrity sha512-A7+f++LodNNc1wGgoRDTt78cOwWm9KVezApgjOMp1W4hM0898nsqBXwF+sbePE7ZRcjN7Sa1Z5m2oN27XkmEjQ==
   dependencies:
     "@codemirror/state" "^6.0.0"
     "@codemirror/view" "^6.23.0"
@@ -24,10 +24,12 @@
     "@lezer/lr" "^1.0.0"
     style-mod "^4.0.0"
 
-"@codemirror/state@^6.0.0", "@codemirror/state@^6.4.0", "@codemirror/state@^6.4.1":
-  version "6.4.1"
-  resolved "https://registry.yarnpkg.com/@codemirror/state/-/state-6.4.1.tgz#da57143695c056d9a3c38705ed34136e2b68171b"
-  integrity sha512-QkEyUiLhsJoZkbumGZlswmAhA7CBU02Wrz7zvH4SrcifbsqwlXShVXg65f3v/ts57W3dqyamEriMhij1Z3Zz4A==
+"@codemirror/state@^6.0.0", "@codemirror/state@^6.4.0", "@codemirror/state@^6.5.2":
+  version "6.5.2"
+  resolved "https://registry.yarnpkg.com/@codemirror/state/-/state-6.5.2.tgz#8eca3a64212a83367dc85475b7d78d5c9b7076c6"
+  integrity sha512-FVqsPqtPWKVVL3dPSxy8wEF/ymIEuVzF1PK3VbUgrxXpJUSHQWWZz4JMToquRxnkw+36LTamCZG2iua2Ptq0fA==
+  dependencies:
+    "@marijn/find-cluster-break" "^1.0.0"
 
 "@codemirror/view@^6.17.0", "@codemirror/view@^6.23.0":
   version "6.28.2"
@@ -82,6 +84,11 @@
   dependencies:
     "@lezer/common" "^1.0.0"
 
+"@marijn/find-cluster-break@^1.0.0":
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/@marijn/find-cluster-break/-/find-cluster-break-1.0.2.tgz#775374306116d51c0c500b8c4face0f9a04752d8"
+  integrity sha512-l0h88YhZFyKdXIFNfSWpyjStDjGHwZ/U7iobcK1cQQD8sejsONdQtTVU+1wVN1PBw40PiiHB1vA5S7VTfQiP9g==
+
 "@ts-stack/markdown@^1.5.0":
   version "1.5.0"
   resolved "https://registry.yarnpkg.com/@ts-stack/markdown/-/markdown-1.5.0.tgz#5dc298a20dc3dc040143c5a5948201eb6bf5419d"
@@ -182,10 +189,10 @@ tslib@^2.3.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.3.tgz#0438f810ad7a9edcde7a241c3d80db693c8cbfe0"
   integrity sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==
 
-typescript@^5.7.2:
-  version "5.7.2"
-  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.7.2.tgz#3169cf8c4c8a828cde53ba9ecb3d2b1d5dd67be6"
-  integrity sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==
+typescript@^5.8.2:
+  version "5.8.2"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-5.8.2.tgz#8170b3702f74b79db2e5a96207c15e65807999e4"
+  integrity sha512-aJn6wq13/afZp/jT9QZmwEjDqqvSGp1VT5GVg+f/t6/oVyrgXM6BY1h9BRh/O5p3PlUPAe+WuiEZOmb/49RqoQ==
 
 undici-types@~6.20.0:
   version "6.20.0"
@@ -215,10 +222,10 @@ vscode-languageserver-types@3.17.5:
   resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz#3273676f0cf2eab40b3f44d085acbb7f08a39d8a"
   integrity sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==
 
-vscode-uri@^3.0.8:
-  version "3.0.8"
-  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.0.8.tgz#1770938d3e72588659a172d0fd4642780083ff9f"
-  integrity sha512-AyFQ0EVmsOZOlAnxoFOGOq1SQDWAB7C6aqMGS23svWAllfOaxbuFvcT8D1i8z3Gyn8fraVeZNNmN6e9bxxXkKw==
+vscode-uri@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/vscode-uri/-/vscode-uri-3.1.0.tgz#dd09ec5a66a38b5c3fffc774015713496d14e09c"
+  integrity sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==
 
 w3c-keyname@^2.2.4:
   version "2.2.8"

playwright.electron.config.ts

@@ -1,4 +1,5 @@
 import { defineConfig, devices } from '@playwright/test'
+import { platform } from 'os'
 
 /**
  * See https://playwright.dev/docs/test-configuration.
@@ -13,7 +14,7 @@ export default defineConfig({
   /* Do not retry */
   retries: 0,
   /* Different amount of parallelism on CI and local. */
-  workers: 8,
+  workers: platform() === 'win32' ? 1 : 2,
   /* Reporter to use. See https://playwright.dev/docs/test-reporters */
   reporter: [
     ['dot'],

public/kcl-samples/step/car-wheel-assembly.step

@@ -3073,7 +3073,7 @@ DATA;
 #3057 = CARTESIAN_POINT('NONE', (0.051104890518972546, -0.039940414856583686, -0.0635));
 #3058 = CARTESIAN_POINT('NONE', (0.052242074077479335, -0.038876903045998674, -0.0635));
 #3059 = CARTESIAN_POINT('NONE', (0.05224392753122875, -0.03887516966712757, -0.0635));
-#3060 = CARTESIAN_POINT('NONE', (0.05311532463588208, -0.03767579444673182, -0.0635));
+#3060 = CARTESIAN_POINT('NONE', (0.05311532463588208, -0.03767579444673181, -0.0635));
 #3061 = CARTESIAN_POINT('NONE', (0.05311674489404425, -0.03767383962907501, -0.0635));
 #3062 = CARTESIAN_POINT('NONE', (0.053776795686355607, -0.03626367057234418, -0.0635));
 #3063 = CARTESIAN_POINT('NONE', (0.05377787147891932, -0.036261372189549286, -0.0635));
@@ -3087,7 +3087,7 @@ DATA;
 #3071 = CARTESIAN_POINT('NONE', (0.053252818350252196, -0.029748655756475863, -0.0635));
 #3072 = CARTESIAN_POINT('NONE', (0.05233460363130192, -0.028414043632913145, -0.0635));
 #3073 = CARTESIAN_POINT('NONE', (0.05233310706682834, -0.028411868397590818, -0.0635));
-#3074 = CARTESIAN_POINT('NONE', (0.051232952266167, -0.02734405921816657, -0.0635));
+#3074 = CARTESIAN_POINT('NONE', (0.05123295226616701, -0.02734405921816657, -0.0635));
 #3075 = CARTESIAN_POINT('NONE', (0.05123115916423111, -0.027342318835171704, -0.0635));
 #3076 = CARTESIAN_POINT('NONE', (0.0499865731843106, -0.02652506813979786, -0.0635));
 #3077 = CARTESIAN_POINT('NONE', (0.049984544679296, -0.026523736132881105, -0.0635));
@@ -3105,7 +3105,7 @@ DATA;
 #3089 = CARTESIAN_POINT('NONE', (0.0407616757108459, -0.02775624333996861, -0.0635));
 #3090 = CARTESIAN_POINT('NONE', (0.03976400232776854, -0.0288872140372878, -0.0635));
 #3091 = CARTESIAN_POINT('NONE', (0.03976237625653429, -0.028889057364922765, -0.0635));
-#3092 = B_SPLINE_CURVE_WITH_KNOTS('NONE', 2, (#3029, #3030, #3031, #3032, #3033, #3034, #3035, #3036, #3037, #3038, #3039, #3040, #3041, #3042, #3043, #3044, #3045, #3046, #3047, #3048, #3049, #3050, #3051, #3052, #3053, #3054, #3055, #3056, #3057, #3058, #3059, #3060, #3061, #3062, #3063, #3064, #3065, #3066, #3067, #3068, #3069, #3070, #3071, #3072, #3073, #3074, #3075, #3076, #3077, #3078, #3079, #3080, #3081, #3082, #3083, #3084, #3085, #3086, #3087, #3088, #3089, #3090, #3091), .UNSPECIFIED., .F., .F., (3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3), (0, 0.01639344262295082, 0.03278688524590164, 0.04918032786885246, 0.06557377049180328, 0.0819672131147541, 0.09836065573770492, 0.11475409836065574, 0.13114754098360656, 0.14754098360655737, 0.1639344262295082, 0.18032786885245902, 0.19672131147540983, 0.21311475409836067, 0.22950819672131148, 0.24590163934426232, 0.26229508196721313, 0.27868852459016397, 0.29508196721311475, 0.3114754098360656, 0.3278688524590164, 0.3442622950819672, 0.36065573770491804, 0.3770491803278689, 0.39344262295081966, 0.4098360655737705, 0.42622950819672134, 0.4426229508196722, 0.45901639344262296, 0.4754098360655738, 0.49180327868852464, 0.5081967213114753, 0.5245901639344261, 0.540983606557377, 0.5573770491803278, 0.5737704918032787, 0.5901639344262295, 0.6065573770491803, 0.6229508196721312, 0.639344262295082, 0.6557377049180328, 0.6721311475409836, 0.6885245901639344, 0.7049180327868853, 0.721311475409836, 0.7377049180327868, 0.7540983606557377, 0.7704918032786885, 0.7868852459016393, 0.8032786885245902, 0.819672131147541, 0.8360655737704918, 0.8524590163934427, 0.8688524590163934, 0.8852459016393442, 0.9016393442622951, 0.9180327868852459, 0.9344262295081968, 0.9508196721311475, 0.9672131147540983, 0.9836065573770492, 1), .UNSPECIFIED.);
+#3092 = B_SPLINE_CURVE_WITH_KNOTS('NONE', 2, (#3029, #3030, #3031, #3032, #3033, #3034, #3035, #3036, #3037, #3038, #3039, #3040, #3041, #3042, #3043, #3044, #3045, #3046, #3047, #3048, #3049, #3050, #3051, #3052, #3053, #3054, #3055, #3056, #3057, #3058, #3059, #3060, #3061, #3062, #3063, #3064, #3065, #3066, #3067, #3068, #3069, #3070, #3071, #3072, #3073, #3074, #3075, #3076, #3077, #3078, #3079, #3080, #3081, #3082, #3083, #3084, #3085, #3086, #3087, #3088, #3089, #3090, #3091), .UNSPECIFIED., .F., .F., (3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3), (-1, -0.9836065573770492, -0.9672131147540983, -0.9508196721311475, -0.9344262295081968, -0.9180327868852459, -0.9016393442622951, -0.8852459016393442, -0.8688524590163934, -0.8524590163934427, -0.8360655737704918, -0.819672131147541, -0.8032786885245902, -0.7868852459016393, -0.7704918032786885, -0.7540983606557377, -0.7377049180327868, -0.721311475409836, -0.7049180327868853, -0.6885245901639344, -0.6721311475409836, -0.6557377049180328, -0.639344262295082, -0.6229508196721312, -0.6065573770491803, -0.5901639344262295, -0.5737704918032787, -0.5573770491803278, -0.540983606557377, -0.5245901639344261, -0.5081967213114753, -0.49180327868852464, -0.4754098360655738, -0.45901639344262296, -0.4426229508196722, -0.42622950819672134, -0.4098360655737705, -0.39344262295081966, -0.3770491803278689, -0.36065573770491804, -0.3442622950819672, -0.3278688524590164, -0.3114754098360656, -0.29508196721311475, -0.27868852459016397, -0.26229508196721313, -0.24590163934426232, -0.22950819672131148, -0.21311475409836067, -0.19672131147540983, -0.18032786885245902, -0.1639344262295082, -0.14754098360655737, -0.13114754098360656, -0.11475409836065574, -0.09836065573770492, -0.0819672131147541, -0.06557377049180328, -0.04918032786885246, -0.03278688524590164, -0.01639344262295082, -0), .UNSPECIFIED.);
 #3093 = DIRECTION('NONE', (0, 0, 1));
 #3094 = VECTOR('NONE', #3093, 1);
 #3095 = CARTESIAN_POINT('NONE', (0.03976237625653429, -0.028889057364922765, -0.063501));

rust/.config/nextest.toml

@@ -6,7 +6,7 @@ uses-engine = { max-threads = 4 }
 after-engine = { max-threads = 12 }
 
 [profile.default]
-slow-timeout = { period = "30s", terminate-after = 1 }
+slow-timeout = { period = "90s", terminate-after = 1 }
 
 [profile.ci]
 slow-timeout = { period = "50s", terminate-after = 5 }

rust/Cargo.lock

@@ -2194,6 +2194,17 @@ dependencies = [
  "crc",
 ]
 
+[[package]]
+name = "lzma-sys"
+version = "0.1.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fda04ab3764e6cde78b9974eec4f779acaba7c4e84b36eca3cf77c581b85d27"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+]
+
 [[package]]
 name = "measurements"
 version = "0.11.0"
@@ -3463,6 +3474,12 @@ dependencies = [
  "digest",
 ]
 
+[[package]]
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
 [[package]]
 name = "sha2"
 version = "0.10.8"
@@ -4378,6 +4395,7 @@ dependencies = [
  "getrandom 0.3.1",
  "js-sys",
  "serde",
+ "sha1_smol",
  "wasm-bindgen",
 ]
 
@@ -4855,6 +4873,15 @@ version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32ac00cd3f8ec9c1d33fb3e7958a82df6989c42d747bd326c822b1d625283547"
 
+[[package]]
+name = "xz2"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "388c44dc09d76f1536602ead6d325eb532f5c122f17782bd57fb47baeeb767e2"
+dependencies = [
+ "lzma-sys",
+]
+
 [[package]]
 name = "yaml-rust"
 version = "0.4.5"
@@ -4999,9 +5026,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "2.2.3"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b280484c454e74e5fff658bbf7df8fdbe7a07c6b2de4a53def232c15ef138f3a"
+checksum = "938cc23ac49778ac8340e366ddc422b2227ea176edb447e23fc0627608dddadd"
 dependencies = [
  "aes",
  "arbitrary",
@@ -5012,15 +5039,16 @@ dependencies = [
  "deflate64",
  "displaydoc",
  "flate2",
+ "getrandom 0.3.1",
  "hmac",
  "indexmap 2.8.0",
  "lzma-rs",
  "memchr",
  "pbkdf2",
- "rand 0.8.5",
  "sha1",
  "thiserror 2.0.12",
  "time",
+ "xz2",
  "zeroize",
  "zopfli",
  "zstd",

rust/Cargo.toml

@@ -49,7 +49,7 @@ tokio = { version = "1" }
 tower-lsp = { version = "0.20.0", default-features = false }
 tracing-subscriber = { version = "0.3.19", features = ["registry", "std", "fmt", "smallvec", "ansi", "tracing-log", "json"] }
 uuid = { version = "1", features = ["v4", "serde"] }
-zip = { version = "2.2.2", default-features = false }
+zip = { version = "2.4.1", default-features = false }
 
 [workspace.lints.clippy]
 assertions_on_result_states = "warn"

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

@@ -802,7 +802,7 @@ fn generate_code_block_test(fn_name: &str, code_block: &str, index: usize) -> pr
                 context_type: crate::execution::ContextType::Mock,
             };
 
-            if let Err(e) = ctx.run(&program, &mut crate::execution::ExecState::new(&ctx.settings)).await {
+            if let Err(e) = ctx.run(&program, &mut crate::execution::ExecState::new(&ctx)).await {
                     return Err(miette::Report::new(crate::errors::Report {
                         error: e.error,
                         filename: format!("{}{}", #fn_name, #index),

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

@@ -15,10 +15,7 @@ mod test_examples_someFn {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -15,10 +15,7 @@ mod test_examples_someFn {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_show {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_show {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -17,10 +17,7 @@ mod test_examples_my_func {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -17,10 +17,7 @@ mod test_examples_line_to {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_min {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_show {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_import {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_import {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_import {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -16,10 +16,7 @@ mod test_examples_show {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

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

@@ -15,10 +15,7 @@ mod test_examples_some_function {
             context_type: crate::execution::ContextType::Mock,
         };
         if let Err(e) = ctx
-            .run(
-                &program,
-                &mut crate::execution::ExecState::new(&ctx.settings),
-            )
+            .run(&program, &mut crate::execution::ExecState::new(&ctx))
             .await
         {
             return Err(miette::Report::new(crate::errors::Report {

rust/kcl-lib/Cargo.toml

@@ -80,7 +80,7 @@ ts-rs = { version = "10.1.0", features = [
 ] }
 tynm = "0.1.10"
 url = { version = "2.5.4", features = ["serde"] }
-uuid = { workspace = true, features = ["v4", "js", "serde"] }
+uuid = { workspace = true, features = ["v4", "v5", "js", "serde"] }
 validator = { version = "0.20.0", features = ["derive"] }
 web-time = "1.1"
 winnow = "=0.6.24"

rust/kcl-lib/benches/benchmark_kcl_samples.rs

@@ -77,7 +77,7 @@ fn run_benchmarks(c: &mut Criterion) {
             b.iter(|| {
                 if let Err(err) = rt.block_on(async {
                     let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default()).await?;
-                    let mut exec_state = kcl_lib::ExecState::new(&ctx.settings);
+                    let mut exec_state = kcl_lib::ExecState::new(&ctx);
                     ctx.run(black_box(&program), &mut exec_state).await?;
                     ctx.close().await;
                     Ok::<(), anyhow::Error>(())

rust/kcl-lib/e2e/executor/main.rs

@@ -2053,7 +2053,7 @@ sketch000 = startSketchOn('XY')
     let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default())
         .await
         .unwrap();
-    let mut exec_state = kcl_lib::ExecState::new(&ctx.settings);
+    let mut exec_state = kcl_lib::ExecState::new(&ctx);
     let program = kcl_lib::Program::parse_no_errs(code).unwrap();
     ctx.run(&program, &mut exec_state).await.unwrap();
 
@@ -2078,7 +2078,7 @@ async fn kcl_test_ensure_nothing_left_in_batch_multi_file() {
     let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default())
         .await
         .unwrap();
-    let mut exec_state = kcl_lib::ExecState::new(&ctx.settings);
+    let mut exec_state = kcl_lib::ExecState::new(&ctx);
     let program = kcl_lib::Program::parse_no_errs(&code).unwrap();
     ctx.run(&program, &mut exec_state).await.unwrap();
 
@@ -2106,7 +2106,7 @@ async fn kcl_test_better_type_names() {
         },
         None => todo!(),
     };
-    assert_eq!(err, "This function expected the input argument to be of type SolidSet but it's actually of type Sketch. You can convert a sketch (2D) into a Solid (3D) by calling a function like `extrude` or `revolve`");
+    assert_eq!(err, "This function expected the input argument to be one or more Solids but it's actually of type Sketch. You can convert a sketch (2D) into a Solid (3D) by calling a function like `extrude` or `revolve`");
 }
 
 #[tokio::test(flavor = "multi_thread")]

rust/kcl-lib/e2e/modify/main.rs

@@ -10,9 +10,9 @@ use pretty_assertions::assert_eq;
 async fn setup(code: &str, name: &str) -> Result<(ExecutorContext, Program, ModuleId, uuid::Uuid)> {
     let program = Program::parse_no_errs(code)?;
     let ctx = kcl_lib::ExecutorContext::new_with_default_client(Default::default()).await?;
-    let mut exec_state = ExecState::new(&ctx.settings);
+    let mut exec_state = ExecState::new(&ctx);
     let result = ctx.run(&program, &mut exec_state).await?;
-    let outcome = exec_state.to_wasm_outcome(result.0);
+    let outcome = exec_state.to_wasm_outcome(result.0).await;
 
     // We need to get the sketch ID.
     let KclValue::Sketch { value: sketch } = outcome.variables.get(name).unwrap() else {

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

@@ -1153,7 +1153,7 @@ fn find_examples(text: &str, filename: &str) -> Vec<(String, String)> {
 async fn run_example(text: &str) -> Result<()> {
     let program = crate::Program::parse_no_errs(text)?;
     let ctx = ExecutorContext::new_with_default_client(crate::UnitLength::Mm).await?;
-    let mut exec_state = crate::execution::ExecState::new(&ctx.settings);
+    let mut exec_state = crate::execution::ExecState::new(&ctx);
     ctx.run(&program, &mut exec_state).await?;
     Ok(())
 }

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

@@ -128,9 +128,9 @@ impl StdLibFnArg {
             ""
         };
         if self.type_ == "Sketch"
-            || self.type_ == "SketchSet"
+            || self.type_ == "[Sketch]"
             || self.type_ == "Solid"
-            || self.type_ == "SolidSet"
+            || self.type_ == "[Solid]"
             || self.type_ == "SketchSurface"
             || self.type_ == "SketchOrSurface"
             || self.type_ == "SolidOrImportedGeometry"

rust/kcl-lib/src/engine/conn.rs

@@ -18,7 +18,7 @@ use tokio::sync::{mpsc, oneshot, RwLock};
 use tokio_tungstenite::tungstenite::Message as WsMsg;
 use uuid::Uuid;
 
-use super::ExecutionKind;
+use super::{EngineStats, ExecutionKind};
 use crate::{
     engine::EngineManager,
     errors::{KclError, KclErrorDetails},
@@ -52,6 +52,7 @@ pub struct EngineConnection {
     session_data: Arc<RwLock<Option<ModelingSessionData>>>,
 
     execution_kind: Arc<RwLock<ExecutionKind>>,
+    stats: EngineStats,
 }
 
 pub struct TcpRead {
@@ -344,6 +345,7 @@ impl EngineConnection {
             default_planes: Default::default(),
             session_data,
             execution_kind: Default::default(),
+            stats: Default::default(),
         })
     }
 }
@@ -378,22 +380,12 @@ impl EngineManager for EngineConnection {
         original
     }
 
-    async fn default_planes(
-        &self,
-        id_generator: &mut IdGenerator,
-        source_range: SourceRange,
-    ) -> Result<DefaultPlanes, KclError> {
-        {
-            let opt = self.default_planes.read().await.as_ref().cloned();
-            if let Some(planes) = opt {
-                return Ok(planes);
-            }
-        } // drop the read lock
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
 
-        let new_planes = self.new_default_planes(id_generator, source_range).await?;
-        *self.default_planes.write().await = Some(new_planes.clone());
-
-        Ok(new_planes)
+    fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>> {
+        self.default_planes.clone()
     }
 
     async fn clear_scene_post_hook(

rust/kcl-lib/src/engine/conn_mock.rs

@@ -16,7 +16,7 @@ use kittycad_modeling_cmds::{self as kcmc};
 use tokio::sync::RwLock;
 use uuid::Uuid;
 
-use super::ExecutionKind;
+use super::{EngineStats, ExecutionKind};
 use crate::{
     errors::KclError,
     exec::DefaultPlanes,
@@ -30,6 +30,9 @@ pub struct EngineConnection {
     batch_end: Arc<RwLock<IndexMap<uuid::Uuid, (WebSocketRequest, SourceRange)>>>,
     artifact_commands: Arc<RwLock<Vec<ArtifactCommand>>>,
     execution_kind: Arc<RwLock<ExecutionKind>>,
+    /// The default planes for the scene.
+    default_planes: Arc<RwLock<Option<DefaultPlanes>>>,
+    stats: EngineStats,
 }
 
 impl EngineConnection {
@@ -39,6 +42,8 @@ impl EngineConnection {
             batch_end: Arc::new(RwLock::new(IndexMap::new())),
             artifact_commands: Arc::new(RwLock::new(Vec::new())),
             execution_kind: Default::default(),
+            default_planes: Default::default(),
+            stats: Default::default(),
         })
     }
 }
@@ -57,6 +62,10 @@ impl crate::engine::EngineManager for EngineConnection {
         Arc::new(RwLock::new(IndexMap::new()))
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn artifact_commands(&self) -> Arc<RwLock<Vec<ArtifactCommand>>> {
         self.artifact_commands.clone()
     }
@@ -73,12 +82,8 @@ impl crate::engine::EngineManager for EngineConnection {
         original
     }
 
-    async fn default_planes(
-        &self,
-        _id_generator: &mut IdGenerator,
-        _source_range: SourceRange,
-    ) -> Result<DefaultPlanes, KclError> {
-        Ok(DefaultPlanes::default())
+    fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>> {
+        self.default_planes.clone()
     }
 
     async fn clear_scene_post_hook(

rust/kcl-lib/src/engine/conn_wasm.rs

@@ -11,7 +11,7 @@ use uuid::Uuid;
 use wasm_bindgen::prelude::*;
 
 use crate::{
-    engine::ExecutionKind,
+    engine::{EngineStats, ExecutionKind},
     errors::{KclError, KclErrorDetails},
     execution::{ArtifactCommand, DefaultPlanes, IdGenerator},
     SourceRange,
@@ -31,12 +31,6 @@ extern "C" {
         idToRangeStr: String,
     ) -> Result<js_sys::Promise, js_sys::Error>;
 
-    #[wasm_bindgen(method, js_name = wasmGetDefaultPlanes, catch)]
-    fn get_default_planes(this: &EngineCommandManager) -> Result<js_sys::Promise, js_sys::Error>;
-
-    #[wasm_bindgen(method, js_name = clearDefaultPlanes, catch)]
-    fn clear_default_planes(this: &EngineCommandManager) -> Result<(), js_sys::Error>;
-
     #[wasm_bindgen(method, js_name = startNewSession, catch)]
     fn start_new_session(this: &EngineCommandManager) -> Result<js_sys::Promise, js_sys::Error>;
 }
@@ -49,6 +43,9 @@ pub struct EngineConnection {
     responses: Arc<RwLock<IndexMap<Uuid, WebSocketResponse>>>,
     artifact_commands: Arc<RwLock<Vec<ArtifactCommand>>>,
     execution_kind: Arc<RwLock<ExecutionKind>>,
+    /// The default planes for the scene.
+    default_planes: Arc<RwLock<Option<DefaultPlanes>>>,
+    stats: EngineStats,
 }
 
 // Safety: WebAssembly will only ever run in a single-threaded context.
@@ -65,6 +62,8 @@ impl EngineConnection {
             responses: Arc::new(RwLock::new(IndexMap::new())),
             artifact_commands: Arc::new(RwLock::new(Vec::new())),
             execution_kind: Default::default(),
+            default_planes: Default::default(),
+            stats: Default::default(),
         })
     }
 
@@ -144,6 +143,10 @@ impl crate::engine::EngineManager for EngineConnection {
         self.responses.clone()
     }
 
+    fn stats(&self) -> &EngineStats {
+        &self.stats
+    }
+
     fn artifact_commands(&self) -> Arc<RwLock<Vec<ArtifactCommand>>> {
         self.artifact_commands.clone()
     }
@@ -160,59 +163,18 @@ impl crate::engine::EngineManager for EngineConnection {
         original
     }
 
-    async fn default_planes(
-        &self,
-        _id_generator: &mut IdGenerator,
-        source_range: SourceRange,
-    ) -> Result<DefaultPlanes, KclError> {
-        // Get the default planes.
-        let promise = self.manager.get_default_planes().map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: e.to_string().into(),
-                source_ranges: vec![source_range],
-            })
-        })?;
-
-        let value = crate::wasm::JsFuture::from(promise).await.map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: format!("Failed to wait for promise from get default planes: {:?}", e),
-                source_ranges: vec![source_range],
-            })
-        })?;
-
-        // Parse the value as a string.
-        let s = value.as_string().ok_or_else(|| {
-            KclError::Engine(KclErrorDetails {
-                message: format!(
-                    "Failed to get string from response from get default planes: `{:?}`",
-                    value
-                ),
-                source_ranges: vec![source_range],
-            })
-        })?;
-
-        // Deserialize the response.
-        let default_planes: DefaultPlanes = serde_json::from_str(&s).map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: format!("Failed to deserialize default planes: {:?}", e),
-                source_ranges: vec![source_range],
-            })
-        })?;
-
-        Ok(default_planes)
+    fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>> {
+        self.default_planes.clone()
     }
 
     async fn clear_scene_post_hook(
         &self,
-        _id_generator: &mut IdGenerator,
+        id_generator: &mut IdGenerator,
         source_range: SourceRange,
     ) -> Result<(), KclError> {
-        self.manager.clear_default_planes().map_err(|e| {
-            KclError::Engine(KclErrorDetails {
-                message: e.to_string().into(),
-                source_ranges: vec![source_range],
-            })
-        })?;
+        // Remake the default planes, since they would have been removed after the scene was cleared.
+        let new_planes = self.new_default_planes(id_generator, source_range).await?;
+        *self.default_planes.write().await = Some(new_planes);
 
         // Start a new session.
         let promise = self.manager.start_new_session().map_err(|e| {

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

@@ -8,7 +8,13 @@ pub mod conn_mock;
 #[cfg(feature = "engine")]
 pub mod conn_wasm;
 
-use std::{collections::HashMap, sync::Arc};
+use std::{
+    collections::HashMap,
+    sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    },
+};
 
 use indexmap::IndexMap;
 use kcmc::{
@@ -58,6 +64,21 @@ impl ExecutionKind {
     }
 }
 
+#[derive(Default, Debug)]
+pub struct EngineStats {
+    pub commands_batched: AtomicUsize,
+    pub batches_sent: AtomicUsize,
+}
+
+impl Clone for EngineStats {
+    fn clone(&self) -> Self {
+        Self {
+            commands_batched: AtomicUsize::new(self.commands_batched.load(Ordering::Relaxed)),
+            batches_sent: AtomicUsize::new(self.batches_sent.load(Ordering::Relaxed)),
+        }
+    }
+}
+
 #[async_trait::async_trait]
 pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
     /// Get the batch of commands to be sent to the engine.
@@ -95,11 +116,28 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
     async fn replace_execution_kind(&self, execution_kind: ExecutionKind) -> ExecutionKind;
 
     /// Get the default planes.
+    fn get_default_planes(&self) -> Arc<RwLock<Option<DefaultPlanes>>>;
+
+    fn stats(&self) -> &EngineStats;
+
+    /// Get the default planes, creating them if they don't exist.
     async fn default_planes(
         &self,
         id_generator: &mut IdGenerator,
-        _source_range: SourceRange,
-    ) -> Result<DefaultPlanes, crate::errors::KclError>;
+        source_range: SourceRange,
+    ) -> Result<DefaultPlanes, KclError> {
+        {
+            let opt = self.get_default_planes().read().await.as_ref().cloned();
+            if let Some(planes) = opt {
+                return Ok(planes);
+            }
+        } // drop the read lock
+
+        let new_planes = self.new_default_planes(id_generator, source_range).await?;
+        *self.get_default_planes().write().await = Some(new_planes.clone());
+
+        Ok(new_planes)
+    }
 
     /// Helpers to be called after clearing a scene.
     /// (These really only apply to wasm for now).
@@ -239,6 +277,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
 
         // Add cmd to the batch.
         self.batch().write().await.push((req, source_range));
+        self.stats().commands_batched.fetch_add(1, Ordering::Relaxed);
 
         Ok(())
     }
@@ -262,6 +301,9 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
         for cmd in cmds {
             extended_cmds.push((WebSocketRequest::ModelingCmdReq(cmd.clone()), source_range));
         }
+        self.stats()
+            .commands_batched
+            .fetch_add(extended_cmds.len(), Ordering::Relaxed);
         self.batch().write().await.extend(extended_cmds);
 
         Ok(())
@@ -288,6 +330,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
 
         // Add cmd to the batch end.
         self.batch_end().write().await.insert(id, (req, source_range));
+        self.stats().commands_batched.fetch_add(1, Ordering::Relaxed);
         Ok(())
     }
 
@@ -390,6 +433,7 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
         if batch_end {
             self.batch_end().write().await.clear();
         }
+        self.stats().batches_sent.fetch_add(1, Ordering::Relaxed);
 
         // We pop off the responses to cleanup our mappings.
         match final_req {

rust/kcl-lib/src/errors.rs

@@ -4,7 +4,7 @@ use thiserror::Error;
 use tower_lsp::lsp_types::{Diagnostic, DiagnosticSeverity};
 
 use crate::{
-    execution::{ArtifactCommand, ArtifactGraph, Operation},
+    execution::{ArtifactCommand, ArtifactGraph, DefaultPlanes, Operation},
     lsp::IntoDiagnostic,
     modules::{ModulePath, ModuleSource},
     source_range::SourceRange,
@@ -131,6 +131,7 @@ pub struct KclErrorWithOutputs {
     pub artifact_graph: ArtifactGraph,
     pub filenames: IndexMap<ModuleId, ModulePath>,
     pub source_files: IndexMap<ModuleId, ModuleSource>,
+    pub default_planes: Option<DefaultPlanes>,
 }
 
 impl KclErrorWithOutputs {
@@ -141,6 +142,7 @@ impl KclErrorWithOutputs {
         artifact_graph: ArtifactGraph,
         filenames: IndexMap<ModuleId, ModulePath>,
         source_files: IndexMap<ModuleId, ModuleSource>,
+        default_planes: Option<DefaultPlanes>,
     ) -> Self {
         Self {
             error,
@@ -149,6 +151,7 @@ impl KclErrorWithOutputs {
             artifact_graph,
             filenames,
             source_files,
+            default_planes,
         }
     }
     pub fn no_outputs(error: KclError) -> Self {
@@ -159,6 +162,7 @@ impl KclErrorWithOutputs {
             artifact_graph: Default::default(),
             filenames: Default::default(),
             source_files: Default::default(),
+            default_planes: Default::default(),
         }
     }
     pub fn into_miette_report_with_outputs(self, code: &str) -> anyhow::Result<ReportWithOutputs> {

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

@@ -180,15 +180,9 @@ pub enum OpKclValue {
     Sketch {
         value: Box<OpSketch>,
     },
-    Sketches {
-        value: Vec<OpSketch>,
-    },
     Solid {
         value: Box<OpSolid>,
     },
-    Solids {
-        value: Vec<OpSolid>,
-    },
     Helix {
         value: Box<OpHelix>,
     },
@@ -234,7 +228,7 @@ impl From<&KclValue> for OpKclValue {
                 ty: ty.clone(),
             },
             KclValue::String { value, .. } => Self::String { value: value.clone() },
-            KclValue::MixedArray { value, .. } => {
+            KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } => {
                 let value = value.iter().map(Self::from).collect();
                 Self::Array { value }
             }
@@ -244,7 +238,7 @@ impl From<&KclValue> for OpKclValue {
             }
             KclValue::TagIdentifier(tag_identifier) => Self::TagIdentifier {
                 value: tag_identifier.value.clone(),
-                artifact_id: tag_identifier.info.as_ref().map(|info| ArtifactId::new(info.id)),
+                artifact_id: tag_identifier.get_cur_info().map(|info| ArtifactId::new(info.id)),
             },
             KclValue::TagDeclarator(node) => Self::TagDeclarator {
                 name: node.name.clone(),
@@ -260,29 +254,11 @@ impl From<&KclValue> for OpKclValue {
                     artifact_id: value.artifact_id,
                 }),
             },
-            KclValue::Sketches { value } => {
-                let value = value
-                    .iter()
-                    .map(|sketch| OpSketch {
-                        artifact_id: sketch.artifact_id,
-                    })
-                    .collect();
-                Self::Sketches { value }
-            }
             KclValue::Solid { value } => Self::Solid {
                 value: Box::new(OpSolid {
                     artifact_id: value.artifact_id,
                 }),
             },
-            KclValue::Solids { value } => {
-                let value = value
-                    .iter()
-                    .map(|solid| OpSolid {
-                        artifact_id: solid.artifact_id,
-                    })
-                    .collect();
-                Self::Solids { value }
-            }
             KclValue::Helix { value } => Self::Helix {
                 value: Box::new(OpHelix {
                     artifact_id: value.artifact_id,
@@ -295,7 +271,6 @@ impl From<&KclValue> for OpKclValue {
             KclValue::Module { .. } => Self::Module {},
             KclValue::KclNone { .. } => Self::KclNone {},
             KclValue::Type { .. } => Self::Type {},
-            KclValue::Tombstone { .. } => unreachable!("Tombstone OpKclValue"),
         }
     }
 }

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

@@ -8,11 +8,11 @@ use crate::{
     execution::{
         annotations,
         cad_op::{OpArg, OpKclValue, Operation},
-        kcl_value::{FunctionSource, NumericType, PrimitiveType, RuntimeType},
+        kcl_value::{FunctionSource, NumericType, RuntimeType},
         memory,
         state::ModuleState,
-        BodyType, EnvironmentRef, ExecState, ExecutorContext, KclValue, Metadata, Plane, PlaneType, Point3d,
-        TagEngineInfo, TagIdentifier,
+        BodyType, EnvironmentRef, ExecState, ExecutorContext, KclValue, Metadata, PlaneType, TagEngineInfo,
+        TagIdentifier,
     },
     modules::{ModuleId, ModulePath, ModuleRepr},
     parsing::ast::types::{
@@ -23,7 +23,7 @@ use crate::{
     },
     source_range::SourceRange,
     std::{
-        args::{Arg, FromKclValue, KwArgs},
+        args::{Arg, KwArgs},
         FunctionKind,
     },
     CompilationError,
@@ -55,10 +55,9 @@ impl ExecutorContext {
         for annotation in annotations {
             if annotation.name() == Some(annotations::SETTINGS) {
                 if matches!(body_type, BodyType::Root) {
-                    let old_units = exec_state.length_unit();
                     exec_state.mod_local.settings.update_from_annotation(annotation)?;
                     let new_units = exec_state.length_unit();
-                    if !self.engine.execution_kind().await.is_isolated() && old_units != new_units {
+                    if !self.engine.execution_kind().await.is_isolated() {
                         self.engine
                             .set_units(new_units.into(), annotation.as_source_range())
                             .await?;
@@ -94,6 +93,7 @@ impl ExecutorContext {
         exec_state: &mut ExecState,
         exec_kind: ExecutionKind,
         preserve_mem: bool,
+        module_id: ModuleId,
         path: &ModulePath,
     ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>), KclError> {
         crate::log::log(format!("enter module {path} {}", exec_state.stack()));
@@ -101,7 +101,12 @@ impl ExecutorContext {
         let old_units = exec_state.length_unit();
         let original_execution = self.engine.replace_execution_kind(exec_kind).await;
 
-        let mut local_state = ModuleState::new(&self.settings, path.std_path(), exec_state.stack().memory.clone());
+        let mut local_state = ModuleState::new(
+            &self.settings,
+            path.std_path(),
+            exec_state.stack().memory.clone(),
+            Some(module_id),
+        );
         if !preserve_mem {
             std::mem::swap(&mut exec_state.mod_local, &mut local_state);
         }
@@ -452,7 +457,7 @@ impl ExecutorContext {
             ModuleRepr::Root => Err(exec_state.circular_import_error(&path, source_range)),
             ModuleRepr::Kcl(_, Some((env_ref, items))) => Ok((*env_ref, items.clone())),
             ModuleRepr::Kcl(program, cache) => self
-                .exec_module_from_ast(program, &path, exec_state, exec_kind, source_range)
+                .exec_module_from_ast(program, module_id, &path, exec_state, exec_kind, source_range)
                 .await
                 .map(|(_, er, items)| {
                     *cache = Some((er, items.clone()));
@@ -483,7 +488,7 @@ impl ExecutorContext {
         let result = match &repr {
             ModuleRepr::Root => Err(exec_state.circular_import_error(&path, source_range)),
             ModuleRepr::Kcl(program, _) => self
-                .exec_module_from_ast(program, &path, exec_state, exec_kind, source_range)
+                .exec_module_from_ast(program, module_id, &path, exec_state, exec_kind, source_range)
                 .await
                 .map(|(val, _, _)| val),
             ModuleRepr::Foreign(geom) => super::import::send_to_engine(geom.clone(), self)
@@ -499,13 +504,16 @@ impl ExecutorContext {
     async fn exec_module_from_ast(
         &self,
         program: &Node<Program>,
+        module_id: ModuleId,
         path: &ModulePath,
         exec_state: &mut ExecState,
         exec_kind: ExecutionKind,
         source_range: SourceRange,
     ) -> Result<(Option<KclValue>, EnvironmentRef, Vec<String>), KclError> {
         exec_state.global.mod_loader.enter_module(path);
-        let result = self.exec_module_body(program, exec_state, exec_kind, false, path).await;
+        let result = self
+            .exec_module_body(program, exec_state, exec_kind, false, module_id, path)
+            .await;
         exec_state.global.mod_loader.leave_module(path);
 
         result.map_err(|err| {
@@ -638,11 +646,11 @@ impl ExecutorContext {
                 let result = self
                     .execute_expr(&expr.expr, exec_state, metadata, &[], statement_kind)
                     .await?;
-                coerce(result, &expr.ty, exec_state).map_err(|value| {
+                coerce(&result, &expr.ty, exec_state).ok_or_else(|| {
                     KclError::Semantic(KclErrorDetails {
                         message: format!(
                             "could not coerce {} value to type {}",
-                            value.human_friendly_type(),
+                            result.human_friendly_type(),
                             expr.ty
                         ),
                         source_ranges: vec![expr.into()],
@@ -654,72 +662,14 @@ impl ExecutorContext {
     }
 }
 
-fn coerce(value: KclValue, ty: &Node<Type>, exec_state: &mut ExecState) -> Result<KclValue, KclValue> {
-    let ty = RuntimeType::from_parsed(ty.inner.clone(), exec_state, (&value).into())
+fn coerce(value: &KclValue, ty: &Node<Type>, exec_state: &mut ExecState) -> Option<KclValue> {
+    let ty = RuntimeType::from_parsed(ty.inner.clone(), exec_state, value.into())
         .map_err(|e| {
             exec_state.err(e);
-            value.clone()
-        })?
-        .ok_or_else(|| value.clone())?;
-    if value.has_type(&ty) {
-        return Ok(value);
-    }
+        })
+        .ok()??;
 
-    // TODO coerce numeric types
-
-    if let KclValue::Object { value, meta } = value {
-        return match ty {
-            RuntimeType::Primitive(PrimitiveType::Plane) => {
-                let origin = value
-                    .get("origin")
-                    .and_then(Point3d::from_kcl_val)
-                    .ok_or_else(|| KclValue::Object {
-                        value: value.clone(),
-                        meta: meta.clone(),
-                    })?;
-                let x_axis = value
-                    .get("xAxis")
-                    .and_then(Point3d::from_kcl_val)
-                    .ok_or_else(|| KclValue::Object {
-                        value: value.clone(),
-                        meta: meta.clone(),
-                    })?;
-                let y_axis = value
-                    .get("yAxis")
-                    .and_then(Point3d::from_kcl_val)
-                    .ok_or_else(|| KclValue::Object {
-                        value: value.clone(),
-                        meta: meta.clone(),
-                    })?;
-                let z_axis = value
-                    .get("zAxis")
-                    .and_then(Point3d::from_kcl_val)
-                    .ok_or_else(|| KclValue::Object {
-                        value: value.clone(),
-                        meta: meta.clone(),
-                    })?;
-
-                let id = exec_state.global.id_generator.next_uuid();
-                let plane = Plane {
-                    id,
-                    artifact_id: id.into(),
-                    origin,
-                    x_axis,
-                    y_axis,
-                    z_axis,
-                    value: PlaneType::Uninit,
-                    // TODO use length unit from origin
-                    units: exec_state.length_unit(),
-                    meta,
-                };
-
-                Ok(KclValue::Plane { value: Box::new(plane) })
-            }
-            _ => Err(KclValue::Object { value, meta }),
-        };
-    }
-
-    Err(value)
+    value.coerce(&ty, exec_state)
 }
 
 impl BinaryPart {
@@ -745,33 +695,7 @@ impl BinaryPart {
 }
 
 impl Node<MemberExpression> {
-    pub fn get_result_array(&self, exec_state: &mut ExecState, index: usize) -> Result<KclValue, KclError> {
-        let array = match &self.object {
-            MemberObject::MemberExpression(member_expr) => member_expr.get_result(exec_state)?,
-            MemberObject::Identifier(identifier) => {
-                let value = exec_state.stack().get(&identifier.name, identifier.into())?;
-                value.clone()
-            }
-        };
-
-        let KclValue::MixedArray { value: array, meta: _ } = array else {
-            return Err(KclError::Semantic(KclErrorDetails {
-                message: format!("MemberExpression array is not an array: {:?}", array),
-                source_ranges: vec![self.clone().into()],
-            }));
-        };
-
-        if let Some(value) = array.get(index) {
-            Ok(value.to_owned())
-        } else {
-            Err(KclError::UndefinedValue(KclErrorDetails {
-                message: format!("index {} not found in array", index),
-                source_ranges: vec![self.clone().into()],
-            }))
-        }
-    }
-
-    pub fn get_result(&self, exec_state: &mut ExecState) -> Result<KclValue, KclError> {
+    fn get_result(&self, exec_state: &mut ExecState) -> Result<KclValue, KclError> {
         let property = Property::try_from(self.computed, self.property.clone(), exec_state, self.into())?;
         let object = match &self.object {
             // TODO: Don't use recursion here, use a loop.
@@ -1372,11 +1296,22 @@ fn update_memory_for_tags_of_geometry(result: &mut KclValue, exec_state: &mut Ex
     // TODO: This could probably be done in a better way, but as of now this was my only idea
     // and it works.
     match result {
-        KclValue::Sketch { value: ref mut sketch } => {
-            for (_, tag) in sketch.tags.iter() {
-                exec_state
-                    .mut_stack()
-                    .insert_or_update(tag.value.clone(), KclValue::TagIdentifier(Box::new(tag.clone())));
+        KclValue::Sketch { value } => {
+            for (name, tag) in value.tags.iter() {
+                if exec_state.stack().cur_frame_contains(name) {
+                    exec_state.mut_stack().update(name, |v, _| {
+                        v.as_mut_tag().unwrap().merge_info(tag);
+                    });
+                } else {
+                    exec_state
+                        .mut_stack()
+                        .add(
+                            name.to_owned(),
+                            KclValue::TagIdentifier(Box::new(tag.clone())),
+                            SourceRange::default(),
+                        )
+                        .unwrap();
+                }
             }
         }
         KclValue::Solid { ref mut value } => {
@@ -1385,7 +1320,7 @@ fn update_memory_for_tags_of_geometry(result: &mut KclValue, exec_state: &mut Ex
                     // Get the past tag and update it.
                     let tag_id = if let Some(t) = value.sketch.tags.get(&tag.name) {
                         let mut t = t.clone();
-                        let Some(ref info) = t.info else {
+                        let Some(info) = t.get_cur_info() else {
                             return Err(KclError::Internal(KclErrorDetails {
                                 message: format!("Tag {} does not have path info", tag.name),
                                 source_ranges: vec![tag.into()],
@@ -1395,59 +1330,70 @@ fn update_memory_for_tags_of_geometry(result: &mut KclValue, exec_state: &mut Ex
                         let mut info = info.clone();
                         info.surface = Some(v.clone());
                         info.sketch = value.id;
-                        t.info = Some(info);
+                        t.info.push((exec_state.stack().current_epoch(), info));
                         t
                     } else {
                         // It's probably a fillet or a chamfer.
                         // Initialize it.
                         TagIdentifier {
                             value: tag.name.clone(),
-                            info: Some(TagEngineInfo {
-                                id: v.get_id(),
-                                surface: Some(v.clone()),
-                                path: None,
-                                sketch: value.id,
-                            }),
+                            info: vec![(
+                                exec_state.stack().current_epoch(),
+                                TagEngineInfo {
+                                    id: v.get_id(),
+                                    surface: Some(v.clone()),
+                                    path: None,
+                                    sketch: value.id,
+                                },
+                            )],
                             meta: vec![Metadata {
                                 source_range: tag.clone().into(),
                             }],
                         }
                     };
 
-                    exec_state
-                        .mut_stack()
-                        .insert_or_update(tag.name.clone(), KclValue::TagIdentifier(Box::new(tag_id.clone())));
-
                     // update the sketch tags.
-                    value.sketch.tags.insert(tag.name.clone(), tag_id);
+                    value.sketch.merge_tags(Some(&tag_id).into_iter());
+
+                    if exec_state.stack().cur_frame_contains(&tag.name) {
+                        exec_state.mut_stack().update(&tag.name, |v, _| {
+                            v.as_mut_tag().unwrap().merge_info(&tag_id);
+                        });
+                    } else {
+                        exec_state
+                            .mut_stack()
+                            .add(
+                                tag.name.clone(),
+                                KclValue::TagIdentifier(Box::new(tag_id)),
+                                SourceRange::default(),
+                            )
+                            .unwrap();
+                    }
                 }
             }
 
             // Find the stale sketch in memory and update it.
             if !value.sketch.tags.is_empty() {
-                let updates: Vec<_> = exec_state
+                let sketches_to_update: Vec<_> = exec_state
                     .stack()
-                    .find_all_in_current_env(|v| match v {
+                    .find_keys_in_current_env(|v| match v {
                         KclValue::Sketch { value: sk } => sk.artifact_id == value.sketch.artifact_id,
                         _ => false,
                     })
-                    .map(|(k, v)| {
-                        let mut sketch = v.as_sketch().unwrap().clone();
-                        for (tag_name, tag_id) in value.sketch.tags.iter() {
-                            sketch.tags.insert(tag_name.clone(), tag_id.clone());
-                        }
-                        (
-                            k.clone(),
-                            KclValue::Sketch {
-                                value: Box::new(sketch),
-                            },
-                        )
-                    })
+                    .cloned()
                     .collect();
 
-                updates
-                    .into_iter()
-                    .for_each(|(k, v)| exec_state.mut_stack().insert_or_update(k, v))
+                for k in sketches_to_update {
+                    exec_state.mut_stack().update(&k, |v, _| {
+                        let sketch = v.as_mut_sketch().unwrap();
+                        sketch.merge_tags(value.sketch.tags.values());
+                    });
+                }
+            }
+        }
+        KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } => {
+            for v in value {
+                update_memory_for_tags_of_geometry(v, exec_state)?;
             }
         }
         _ => {}
@@ -1459,7 +1405,7 @@ impl Node<TagDeclarator> {
     pub async fn execute(&self, exec_state: &mut ExecState) -> Result<KclValue, KclError> {
         let memory_item = KclValue::TagIdentifier(Box::new(TagIdentifier {
             value: self.name.clone(),
-            info: None,
+            info: Vec::new(),
             meta: vec![Metadata {
                 source_range: self.into(),
             }],
@@ -1966,14 +1912,16 @@ impl FunctionSource {
 
 #[cfg(test)]
 mod test {
+    use std::sync::Arc;
+
     use super::*;
     use crate::{
-        execution::{memory::Stack, parse_execute},
+        execution::{memory::Stack, parse_execute, ContextType},
         parsing::ast::types::{DefaultParamVal, Identifier, Parameter},
     };
 
-    #[test]
-    fn test_assign_args_to_params() {
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_assign_args_to_params() {
         // Set up a little framework for this test.
         fn mem(number: usize) -> KclValue {
             KclValue::Number {
@@ -2084,7 +2032,16 @@ mod test {
                 digest: None,
             });
             let args = args.into_iter().map(Arg::synthetic).collect();
-            let mut exec_state = ExecState::new(&Default::default());
+            let exec_ctxt = ExecutorContext {
+                engine: Arc::new(Box::new(
+                    crate::engine::conn_mock::EngineConnection::new().await.unwrap(),
+                )),
+                fs: Arc::new(crate::fs::FileManager::new()),
+                stdlib: Arc::new(crate::std::StdLib::new()),
+                settings: Default::default(),
+                context_type: ContextType::Mock,
+            };
+            let mut exec_state = ExecState::new(&exec_ctxt);
             exec_state.mod_local.stack = Stack::new_for_tests();
             let actual = assign_args_to_params(func_expr, args, &mut exec_state).map(|_| exec_state.mod_local.stack);
             assert_eq!(

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

@@ -23,8 +23,8 @@ type Point3D = kcmc::shared::Point3d<f64>;
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum Geometry {
-    Sketch(Box<Sketch>),
-    Solid(Box<Solid>),
+    Sketch(Sketch),
+    Solid(Solid),
 }
 
 impl Geometry {
@@ -52,8 +52,8 @@ impl Geometry {
 #[serde(tag = "type")]
 #[allow(clippy::vec_box)]
 pub enum Geometries {
-    Sketches(Vec<Box<Sketch>>),
-    Solids(Vec<Box<Solid>>),
+    Sketches(Vec<Sketch>),
+    Solids(Vec<Solid>),
 }
 
 impl From<Geometry> for Geometries {
@@ -65,150 +65,6 @@ impl From<Geometry> for Geometries {
     }
 }
 
-/// A sketch or a group of sketches.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(tag = "type", rename_all = "camelCase")]
-#[allow(clippy::vec_box)]
-pub enum SketchSet {
-    Sketch(Box<Sketch>),
-    Sketches(Vec<Box<Sketch>>),
-}
-
-impl SketchSet {
-    pub fn meta(&self) -> Vec<Metadata> {
-        match self {
-            SketchSet::Sketch(sg) => sg.meta.clone(),
-            SketchSet::Sketches(sg) => sg.iter().flat_map(|sg| sg.meta.clone()).collect(),
-        }
-    }
-}
-
-impl From<SketchSet> for Vec<Sketch> {
-    fn from(value: SketchSet) -> Self {
-        match value {
-            SketchSet::Sketch(sg) => vec![*sg],
-            SketchSet::Sketches(sgs) => sgs.into_iter().map(|sg| *sg).collect(),
-        }
-    }
-}
-
-impl From<Sketch> for SketchSet {
-    fn from(sg: Sketch) -> Self {
-        SketchSet::Sketch(Box::new(sg))
-    }
-}
-
-impl From<Box<Sketch>> for SketchSet {
-    fn from(sg: Box<Sketch>) -> Self {
-        SketchSet::Sketch(sg)
-    }
-}
-
-impl From<Vec<Sketch>> for SketchSet {
-    fn from(sg: Vec<Sketch>) -> Self {
-        if sg.len() == 1 {
-            SketchSet::Sketch(Box::new(sg[0].clone()))
-        } else {
-            SketchSet::Sketches(sg.into_iter().map(Box::new).collect())
-        }
-    }
-}
-
-impl From<Vec<Box<Sketch>>> for SketchSet {
-    fn from(sg: Vec<Box<Sketch>>) -> Self {
-        if sg.len() == 1 {
-            SketchSet::Sketch(sg[0].clone())
-        } else {
-            SketchSet::Sketches(sg)
-        }
-    }
-}
-
-impl From<SketchSet> for Vec<Box<Sketch>> {
-    fn from(sg: SketchSet) -> Self {
-        match sg {
-            SketchSet::Sketch(sg) => vec![sg],
-            SketchSet::Sketches(sgs) => sgs,
-        }
-    }
-}
-
-impl From<&Sketch> for Vec<Box<Sketch>> {
-    fn from(sg: &Sketch) -> Self {
-        vec![Box::new(sg.clone())]
-    }
-}
-
-impl From<Box<Sketch>> for Vec<Box<Sketch>> {
-    fn from(sg: Box<Sketch>) -> Self {
-        vec![sg]
-    }
-}
-
-/// A solid or a group of solids.
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(tag = "type", rename_all = "camelCase")]
-#[allow(clippy::vec_box)]
-pub enum SolidSet {
-    Solid(Box<Solid>),
-    Solids(Vec<Box<Solid>>),
-}
-
-impl From<Solid> for SolidSet {
-    fn from(eg: Solid) -> Self {
-        SolidSet::Solid(Box::new(eg))
-    }
-}
-
-impl From<Box<Solid>> for SolidSet {
-    fn from(eg: Box<Solid>) -> Self {
-        SolidSet::Solid(eg)
-    }
-}
-
-impl From<Vec<Solid>> for SolidSet {
-    fn from(eg: Vec<Solid>) -> Self {
-        if eg.len() == 1 {
-            SolidSet::Solid(Box::new(eg[0].clone()))
-        } else {
-            SolidSet::Solids(eg.into_iter().map(Box::new).collect())
-        }
-    }
-}
-
-impl From<Vec<Box<Solid>>> for SolidSet {
-    fn from(eg: Vec<Box<Solid>>) -> Self {
-        if eg.len() == 1 {
-            SolidSet::Solid(eg[0].clone())
-        } else {
-            SolidSet::Solids(eg)
-        }
-    }
-}
-
-impl From<SolidSet> for Vec<Box<Solid>> {
-    fn from(eg: SolidSet) -> Self {
-        match eg {
-            SolidSet::Solid(eg) => vec![eg],
-            SolidSet::Solids(egs) => egs,
-        }
-    }
-}
-
-impl From<&Solid> for Vec<Box<Solid>> {
-    fn from(eg: &Solid) -> Self {
-        vec![Box::new(eg.clone())]
-    }
-}
-
-impl From<Box<Solid>> for Vec<Box<Solid>> {
-    fn from(eg: Box<Solid>) -> Self {
-        vec![eg]
-    }
-}
-
 /// Data for an imported geometry.
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
@@ -228,17 +84,29 @@ pub struct ImportedGeometry {
 #[serde(tag = "type", rename_all = "camelCase")]
 #[allow(clippy::vec_box)]
 pub enum SolidOrImportedGeometry {
-    Solid(Box<Solid>),
     ImportedGeometry(Box<ImportedGeometry>),
-    SolidSet(Vec<Box<Solid>>),
+    SolidSet(Vec<Solid>),
 }
 
 impl From<SolidOrImportedGeometry> for crate::execution::KclValue {
     fn from(value: SolidOrImportedGeometry) -> Self {
         match value {
-            SolidOrImportedGeometry::Solid(s) => crate::execution::KclValue::Solid { value: s },
             SolidOrImportedGeometry::ImportedGeometry(s) => crate::execution::KclValue::ImportedGeometry(*s),
-            SolidOrImportedGeometry::SolidSet(s) => crate::execution::KclValue::Solids { value: s },
+            SolidOrImportedGeometry::SolidSet(mut s) => {
+                if s.len() == 1 {
+                    crate::execution::KclValue::Solid {
+                        value: Box::new(s.pop().unwrap()),
+                    }
+                } else {
+                    crate::execution::KclValue::HomArray {
+                        value: s
+                            .into_iter()
+                            .map(|s| crate::execution::KclValue::Solid { value: Box::new(s) })
+                            .collect(),
+                        ty: crate::execution::PrimitiveType::Solid,
+                    }
+                }
+            }
         }
     }
 }
@@ -246,7 +114,6 @@ impl From<SolidOrImportedGeometry> for crate::execution::KclValue {
 impl SolidOrImportedGeometry {
     pub(crate) fn ids(&self) -> Vec<uuid::Uuid> {
         match self {
-            SolidOrImportedGeometry::Solid(s) => vec![s.id],
             SolidOrImportedGeometry::ImportedGeometry(s) => vec![s.id],
             SolidOrImportedGeometry::SolidSet(s) => s.iter().map(|s| s.id).collect(),
         }
@@ -370,7 +237,7 @@ impl Plane {
     }
 
     pub(crate) fn from_plane_data(value: PlaneData, exec_state: &mut ExecState) -> Self {
-        let id = exec_state.global.id_generator.next_uuid();
+        let id = exec_state.next_uuid();
         match value {
             PlaneData::XY => Plane {
                 id,
@@ -443,17 +310,20 @@ impl Plane {
                 x_axis,
                 y_axis,
                 z_axis,
-            } => Plane {
-                id,
-                artifact_id: id.into(),
-                origin,
-                x_axis,
-                y_axis,
-                z_axis,
-                value: PlaneType::Custom,
-                units: exec_state.length_unit(),
-                meta: vec![],
-            },
+            } => {
+                let id = exec_state.next_uuid();
+                Plane {
+                    id,
+                    artifact_id: id.into(),
+                    origin,
+                    x_axis,
+                    y_axis,
+                    z_axis,
+                    value: PlaneType::Custom,
+                    units: exec_state.length_unit(),
+                    meta: vec![],
+                }
+            }
         }
     }
 
@@ -636,19 +506,35 @@ impl GetTangentialInfoFromPathsResult {
 }
 
 impl Sketch {
-    pub(crate) fn add_tag(&mut self, tag: NodeRef<'_, TagDeclarator>, current_path: &Path) {
+    pub(crate) fn add_tag(&mut self, tag: NodeRef<'_, TagDeclarator>, current_path: &Path, exec_state: &ExecState) {
         let mut tag_identifier: TagIdentifier = tag.into();
         let base = current_path.get_base();
-        tag_identifier.info = Some(TagEngineInfo {
-            id: base.geo_meta.id,
-            sketch: self.id,
-            path: Some(current_path.clone()),
-            surface: None,
-        });
+        tag_identifier.info.push((
+            exec_state.stack().current_epoch(),
+            TagEngineInfo {
+                id: base.geo_meta.id,
+                sketch: self.id,
+                path: Some(current_path.clone()),
+                surface: None,
+            },
+        ));
 
         self.tags.insert(tag.name.to_string(), tag_identifier);
     }
 
+    pub(crate) fn merge_tags<'a>(&mut self, tags: impl Iterator<Item = &'a TagIdentifier>) {
+        for t in tags {
+            match self.tags.get_mut(&t.value) {
+                Some(id) => {
+                    id.merge_info(t);
+                }
+                None => {
+                    self.tags.insert(t.value.clone(), t.clone());
+                }
+            }
+        }
+    }
+
     /// Get the path most recently sketched.
     pub(crate) fn latest_path(&self) -> Option<&Path> {
         self.paths.last()
@@ -946,6 +832,19 @@ pub enum Path {
         #[ts(type = "[number, number]")]
         p3: [f64; 2],
     },
+    ArcThreePoint {
+        #[serde(flatten)]
+        base: BasePath,
+        /// Point 1 of the arc (base on the end of previous segment)
+        #[ts(type = "[number, number]")]
+        p1: [f64; 2],
+        /// Point 2 of the arc (interior kwarg)
+        #[ts(type = "[number, number]")]
+        p2: [f64; 2],
+        /// Point 3 of the arc (end kwarg)
+        #[ts(type = "[number, number]")]
+        p3: [f64; 2],
+    },
     /// A path that is horizontal.
     Horizontal {
         #[serde(flatten)]
@@ -1006,6 +905,7 @@ impl From<&Path> for PathType {
             Path::AngledLineTo { .. } => Self::AngledLineTo,
             Path::Base { .. } => Self::Base,
             Path::Arc { .. } => Self::Arc,
+            Path::ArcThreePoint { .. } => Self::Arc,
         }
     }
 }
@@ -1022,6 +922,7 @@ impl Path {
             Path::Circle { base, .. } => base.geo_meta.id,
             Path::CircleThreePoint { base, .. } => base.geo_meta.id,
             Path::Arc { base, .. } => base.geo_meta.id,
+            Path::ArcThreePoint { base, .. } => base.geo_meta.id,
         }
     }
 
@@ -1036,6 +937,7 @@ impl Path {
             Path::Circle { base, .. } => base.tag.clone(),
             Path::CircleThreePoint { base, .. } => base.tag.clone(),
             Path::Arc { base, .. } => base.tag.clone(),
+            Path::ArcThreePoint { base, .. } => base.tag.clone(),
         }
     }
 
@@ -1050,6 +952,7 @@ impl Path {
             Path::Circle { base, .. } => base,
             Path::CircleThreePoint { base, .. } => base,
             Path::Arc { base, .. } => base,
+            Path::ArcThreePoint { base, .. } => base,
         }
     }
 
@@ -1099,6 +1002,10 @@ impl Path {
                 // TODO: Call engine utils to figure this out.
                 linear_distance(self.get_from(), self.get_to())
             }
+            Self::ArcThreePoint { .. } => {
+                // TODO: Call engine utils to figure this out.
+                linear_distance(self.get_from(), self.get_to())
+            }
         }
     }
 
@@ -1113,6 +1020,7 @@ impl Path {
             Path::Circle { base, .. } => Some(base),
             Path::CircleThreePoint { base, .. } => Some(base),
             Path::Arc { base, .. } => Some(base),
+            Path::ArcThreePoint { base, .. } => Some(base),
         }
     }
 
@@ -1124,6 +1032,17 @@ impl Path {
                 center: *center,
                 ccw: *ccw,
             },
+            Path::ArcThreePoint { p1, p2, p3, .. } => {
+                let circle_center =
+                    crate::std::utils::calculate_circle_from_3_points([(*p1).into(), (*p2).into(), (*p3).into()]);
+                let radius = linear_distance(&[circle_center.center.x, circle_center.center.y], p1);
+                let center_point = [circle_center.center.x, circle_center.center.y];
+                GetTangentialInfoFromPathsResult::Circle {
+                    center: center_point,
+                    ccw: true,
+                    radius,
+                }
+            }
             Path::Circle {
                 center, ccw, radius, ..
             } => GetTangentialInfoFromPathsResult::Circle {

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

@@ -0,0 +1,83 @@
+//! A generator for ArtifactIds that can be stable across executions.
+
+use crate::execution::ModuleId;
+
+const NAMESPACE_KCL: uuid::Uuid = uuid::uuid!("efcd6508-4ce6-4a09-8317-e6a6994a3cd7");
+
+/// A generator for ArtifactIds that can be stable across executions.
+#[derive(Debug, Clone, Default, PartialEq)]
+pub struct IdGenerator {
+    module_id: Option<ModuleId>,
+    next_id: u64,
+}
+
+impl IdGenerator {
+    pub fn new(module_id: Option<ModuleId>) -> Self {
+        Self { module_id, next_id: 0 }
+    }
+
+    pub fn next_uuid(&mut self) -> uuid::Uuid {
+        let next_id = self.next_id;
+
+        let next = format!(
+            "{} {}",
+            self.module_id.map(|id| id.to_string()).unwrap_or("none".to_string()),
+            next_id
+        );
+        let next_uuid = uuid::Uuid::new_v5(&NAMESPACE_KCL, next.as_bytes());
+
+        self.next_id += 1;
+
+        next_uuid
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_id_generator() {
+        let mut generator = IdGenerator::new(Some(ModuleId::default()));
+
+        let uuid1 = generator.next_uuid();
+        let uuid2 = generator.next_uuid();
+
+        assert_ne!(uuid1, uuid2);
+    }
+
+    #[test]
+    // Test that the same generator produces the same UUIDs.
+    fn test_id_generator_stable() {
+        let mut generator = IdGenerator::new(Some(ModuleId::default()));
+
+        let uuid1 = generator.next_uuid();
+        let uuid2 = generator.next_uuid();
+
+        let mut generator = IdGenerator::new(Some(ModuleId::default()));
+
+        let uuid3 = generator.next_uuid();
+        let uuid4 = generator.next_uuid();
+
+        assert_eq!(uuid1, uuid3);
+        assert_eq!(uuid2, uuid4);
+    }
+
+    #[test]
+    // Generate 20 uuids and make sure all are unique.
+    fn test_id_generator_unique() {
+        let mut generator = IdGenerator::new(Some(ModuleId::default()));
+
+        let mut uuids = Vec::new();
+
+        for _ in 0..20 {
+            uuids.push(generator.next_uuid());
+        }
+
+        for i in 0..uuids.len() {
+            for j in i + 1..uuids.len() {
+                assert_ne!(uuids[i], uuids[j]);
+            }
+        }
+    }
+}

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

@@ -6,13 +6,12 @@ use serde::{Deserialize, Serialize};
 
 use super::{
     memory::{self, EnvironmentRef},
-    MetaSettings,
+    MetaSettings, Point3d,
 };
 use crate::{
     errors::KclErrorDetails,
     execution::{
-        ExecState, ExecutorContext, Face, Helix, ImportedGeometry, Metadata, Plane, Sketch, SketchSet, Solid, SolidSet,
-        TagIdentifier,
+        ExecState, ExecutorContext, Face, Helix, ImportedGeometry, Metadata, Plane, Sketch, Solid, TagIdentifier,
     },
     parsing::{
         ast::types::{
@@ -21,7 +20,10 @@ use crate::{
         },
         token::NumericSuffix,
     },
-    std::{args::Arg, StdFnProps},
+    std::{
+        args::{Arg, FromKclValue},
+        StdFnProps,
+    },
     CompilationError, KclError, ModuleId, SourceRange,
 };
 
@@ -58,6 +60,13 @@ pub enum KclValue {
         #[serde(skip)]
         meta: Vec<Metadata>,
     },
+    // An array where all values have a shared type (not necessarily the same principal type).
+    HomArray {
+        value: Vec<KclValue>,
+        // The type of values, not the array type.
+        #[serde(skip)]
+        ty: PrimitiveType,
+    },
     Object {
         value: KclObjectFields,
         #[serde(skip)]
@@ -74,15 +83,9 @@ pub enum KclValue {
     Sketch {
         value: Box<Sketch>,
     },
-    Sketches {
-        value: Vec<Box<Sketch>>,
-    },
     Solid {
         value: Box<Solid>,
     },
-    Solids {
-        value: Vec<Box<Solid>>,
-    },
     Helix {
         value: Box<Helix>,
     },
@@ -111,12 +114,6 @@ pub enum KclValue {
         #[serde(skip)]
         meta: Vec<Metadata>,
     },
-    // Only used for memory management. Should never be visible outside of the memory module.
-    Tombstone {
-        value: (),
-        #[serde(skip)]
-        meta: Vec<Metadata>,
-    },
 }
 
 #[derive(Debug, Clone, PartialEq, Default)]
@@ -145,48 +142,46 @@ impl JsonSchema for FunctionSource {
     }
 }
 
-impl From<SketchSet> for KclValue {
-    fn from(sg: SketchSet) -> Self {
-        match sg {
-            SketchSet::Sketch(value) => KclValue::Sketch { value },
-            SketchSet::Sketches(value) => KclValue::Sketches { value },
-        }
-    }
-}
-
-impl From<Vec<Box<Sketch>>> for KclValue {
-    fn from(sg: Vec<Box<Sketch>>) -> Self {
-        KclValue::Sketches { value: sg }
-    }
-}
-
-impl From<SolidSet> for KclValue {
-    fn from(eg: SolidSet) -> Self {
-        match eg {
-            SolidSet::Solid(eg) => KclValue::Solid { value: eg },
-            SolidSet::Solids(egs) => KclValue::Solids { value: egs },
-        }
-    }
-}
-
-impl From<Vec<Box<Solid>>> for KclValue {
-    fn from(eg: Vec<Box<Solid>>) -> Self {
+impl From<Vec<Sketch>> for KclValue {
+    fn from(mut eg: Vec<Sketch>) -> Self {
         if eg.len() == 1 {
-            KclValue::Solid { value: eg[0].clone() }
+            KclValue::Sketch {
+                value: Box::new(eg.pop().unwrap()),
+            }
         } else {
-            KclValue::Solids { value: eg }
+            KclValue::HomArray {
+                value: eg
+                    .into_iter()
+                    .map(|s| KclValue::Sketch { value: Box::new(s) })
+                    .collect(),
+                ty: crate::execution::PrimitiveType::Sketch,
+            }
         }
     }
 }
+
+impl From<Vec<Solid>> for KclValue {
+    fn from(mut eg: Vec<Solid>) -> Self {
+        if eg.len() == 1 {
+            KclValue::Solid {
+                value: Box::new(eg.pop().unwrap()),
+            }
+        } else {
+            KclValue::HomArray {
+                value: eg.into_iter().map(|s| KclValue::Solid { value: Box::new(s) }).collect(),
+                ty: crate::execution::PrimitiveType::Solid,
+            }
+        }
+    }
+}
+
 impl From<KclValue> for Vec<SourceRange> {
     fn from(item: KclValue) -> Self {
         match item {
             KclValue::TagDeclarator(t) => vec![SourceRange::new(t.start, t.end, t.module_id)],
             KclValue::TagIdentifier(t) => to_vec_sr(&t.meta),
             KclValue::Solid { value } => to_vec_sr(&value.meta),
-            KclValue::Solids { value } => value.iter().flat_map(|eg| to_vec_sr(&eg.meta)).collect(),
             KclValue::Sketch { value } => to_vec_sr(&value.meta),
-            KclValue::Sketches { value } => value.iter().flat_map(|eg| to_vec_sr(&eg.meta)).collect(),
             KclValue::Helix { value } => to_vec_sr(&value.meta),
             KclValue::ImportedGeometry(i) => to_vec_sr(&i.meta),
             KclValue::Function { meta, .. } => to_vec_sr(&meta),
@@ -196,12 +191,12 @@ impl From<KclValue> for Vec<SourceRange> {
             KclValue::Number { meta, .. } => to_vec_sr(&meta),
             KclValue::String { meta, .. } => to_vec_sr(&meta),
             KclValue::MixedArray { meta, .. } => to_vec_sr(&meta),
+            KclValue::HomArray { value, .. } => value.iter().flat_map(Into::<Vec<SourceRange>>::into).collect(),
             KclValue::Object { meta, .. } => to_vec_sr(&meta),
             KclValue::Module { meta, .. } => to_vec_sr(&meta),
             KclValue::Uuid { meta, .. } => to_vec_sr(&meta),
             KclValue::Type { meta, .. } => to_vec_sr(&meta),
             KclValue::KclNone { meta, .. } => to_vec_sr(&meta),
-            KclValue::Tombstone { .. } => unreachable!("Tombstone SourceRange"),
         }
     }
 }
@@ -216,9 +211,7 @@ impl From<&KclValue> for Vec<SourceRange> {
             KclValue::TagDeclarator(t) => vec![SourceRange::new(t.start, t.end, t.module_id)],
             KclValue::TagIdentifier(t) => to_vec_sr(&t.meta),
             KclValue::Solid { value } => to_vec_sr(&value.meta),
-            KclValue::Solids { value } => value.iter().flat_map(|eg| to_vec_sr(&eg.meta)).collect(),
             KclValue::Sketch { value } => to_vec_sr(&value.meta),
-            KclValue::Sketches { value } => value.iter().flat_map(|eg| to_vec_sr(&eg.meta)).collect(),
             KclValue::Helix { value } => to_vec_sr(&value.meta),
             KclValue::ImportedGeometry(i) => to_vec_sr(&i.meta),
             KclValue::Function { meta, .. } => to_vec_sr(meta),
@@ -229,11 +222,11 @@ impl From<&KclValue> for Vec<SourceRange> {
             KclValue::String { meta, .. } => to_vec_sr(meta),
             KclValue::Uuid { meta, .. } => to_vec_sr(meta),
             KclValue::MixedArray { meta, .. } => to_vec_sr(meta),
+            KclValue::HomArray { value, .. } => value.iter().flat_map(Into::<Vec<SourceRange>>::into).collect(),
             KclValue::Object { meta, .. } => to_vec_sr(meta),
             KclValue::Module { meta, .. } => to_vec_sr(meta),
             KclValue::KclNone { meta, .. } => to_vec_sr(meta),
             KclValue::Type { meta, .. } => to_vec_sr(meta),
-            KclValue::Tombstone { .. } => unreachable!("Tombstone &SourceRange"),
         }
     }
 }
@@ -253,22 +246,20 @@ impl KclValue {
             KclValue::Number { meta, .. } => meta.clone(),
             KclValue::String { value: _, meta } => meta.clone(),
             KclValue::MixedArray { value: _, meta } => meta.clone(),
+            KclValue::HomArray { value, .. } => value.iter().flat_map(|v| v.metadata()).collect(),
             KclValue::Object { value: _, meta } => meta.clone(),
             KclValue::TagIdentifier(x) => x.meta.clone(),
             KclValue::TagDeclarator(x) => vec![x.metadata()],
             KclValue::Plane { value } => value.meta.clone(),
             KclValue::Face { value } => value.meta.clone(),
             KclValue::Sketch { value } => value.meta.clone(),
-            KclValue::Sketches { value } => value.iter().flat_map(|sketch| &sketch.meta).copied().collect(),
             KclValue::Solid { value } => value.meta.clone(),
-            KclValue::Solids { value } => value.iter().flat_map(|sketch| &sketch.meta).copied().collect(),
             KclValue::Helix { value } => value.meta.clone(),
             KclValue::ImportedGeometry(x) => x.meta.clone(),
             KclValue::Function { meta, .. } => meta.clone(),
             KclValue::Module { meta, .. } => meta.clone(),
             KclValue::KclNone { meta, .. } => meta.clone(),
             KclValue::Type { meta, .. } => meta.clone(),
-            KclValue::Tombstone { .. } => unreachable!("Tombstone Metadata"),
         }
     }
 
@@ -285,29 +276,6 @@ impl KclValue {
         Some(ast.as_source_range())
     }
 
-    pub(crate) fn get_solid_set(&self) -> Result<SolidSet> {
-        match self {
-            KclValue::Solid { value } => Ok(SolidSet::Solid(value.clone())),
-            KclValue::Solids { value } => Ok(SolidSet::Solids(value.clone())),
-            KclValue::MixedArray { value, .. } => {
-                let solids: Vec<_> = value
-                    .iter()
-                    .enumerate()
-                    .map(|(i, v)| {
-                        v.as_solid().map(|v| v.to_owned()).map(Box::new).ok_or_else(|| {
-                            anyhow::anyhow!(
-                                "expected this array to only contain solids, but element {i} was actually {}",
-                                v.human_friendly_type()
-                            )
-                        })
-                    })
-                    .collect::<Result<_, _>>()?;
-                Ok(SolidSet::Solids(solids))
-            }
-            _ => anyhow::bail!("Not a solid or solids: {:?}", self),
-        }
-    }
-
     #[allow(unused)]
     pub(crate) fn none() -> Self {
         Self::KclNone {
@@ -324,9 +292,7 @@ impl KclValue {
             KclValue::TagDeclarator(_) => "TagDeclarator",
             KclValue::TagIdentifier(_) => "TagIdentifier",
             KclValue::Solid { .. } => "Solid",
-            KclValue::Solids { .. } => "Solids",
             KclValue::Sketch { .. } => "Sketch",
-            KclValue::Sketches { .. } => "Sketches",
             KclValue::Helix { .. } => "Helix",
             KclValue::ImportedGeometry(_) => "ImportedGeometry",
             KclValue::Function { .. } => "Function",
@@ -336,11 +302,11 @@ impl KclValue {
             KclValue::Number { .. } => "number",
             KclValue::String { .. } => "string (text)",
             KclValue::MixedArray { .. } => "array (list)",
+            KclValue::HomArray { .. } => "array (list)",
             KclValue::Object { .. } => "object",
             KclValue::Module { .. } => "module",
             KclValue::Type { .. } => "type",
             KclValue::KclNone { .. } => "None",
-            KclValue::Tombstone { .. } => "TOMBSTONE",
         }
     }
 
@@ -367,16 +333,14 @@ impl KclValue {
         }
     }
 
-    pub(crate) fn map_env_ref(&self, env_map: &HashMap<EnvironmentRef, EnvironmentRef>) -> Self {
+    pub(crate) fn map_env_ref(&self, old_env: usize, new_env: usize) -> Self {
         let mut result = self.clone();
         if let KclValue::Function {
             value: FunctionSource::User { ref mut memory, .. },
             ..
         } = result
         {
-            if let Some(new) = env_map.get(memory) {
-                *memory = *new;
-            }
+            memory.replace_env(old_env, new_env);
         }
         result
     }
@@ -501,6 +465,21 @@ impl KclValue {
         }
     }
 
+    pub fn as_mut_sketch(&mut self) -> Option<&mut Sketch> {
+        if let KclValue::Sketch { value } = self {
+            Some(value)
+        } else {
+            None
+        }
+    }
+
+    pub fn as_mut_tag(&mut self) -> Option<&mut TagIdentifier> {
+        if let KclValue::TagIdentifier(value) = self {
+            Some(value)
+        } else {
+            None
+        }
+    }
     pub fn as_f64(&self) -> Option<f64> {
         if let KclValue::Number { value, .. } = &self {
             Some(*value)
@@ -563,17 +542,6 @@ impl KclValue {
         }
     }
 
-    /// Get an optional tag from a memory item.
-    pub fn get_tag_declarator_opt(&self) -> Result<Option<TagNode>, KclError> {
-        match self {
-            KclValue::TagDeclarator(t) => Ok(Some((**t).clone())),
-            _ => Err(KclError::Semantic(KclErrorDetails {
-                message: format!("Not a tag declarator: {:?}", self),
-                source_ranges: self.clone().into(),
-            })),
-        }
-    }
-
     /// If this KCL value is a bool, retrieve it.
     pub fn get_bool(&self) -> Result<bool, KclError> {
         let Self::Bool { value: b, .. } = self else {
@@ -594,6 +562,215 @@ impl KclValue {
         self_ty.subtype(ty)
     }
 
+    /// Coerce `self` to a new value which has `ty` as it's closest supertype.
+    ///
+    /// If the result is Some, then:
+    ///   - result.principal_type().unwrap().subtype(ty)
+    ///
+    /// If self.principal_type() == ty then result == self
+    pub fn coerce(&self, ty: &RuntimeType, exec_state: &mut ExecState) -> Option<KclValue> {
+        match ty {
+            RuntimeType::Primitive(ty) => self.coerce_to_primitive_type(ty, exec_state),
+            RuntimeType::Array(ty, len) => self.coerce_to_array_type(ty, *len, exec_state),
+            RuntimeType::Tuple(tys) => self.coerce_to_tuple_type(tys, exec_state),
+            RuntimeType::Union(tys) => self.coerce_to_union_type(tys, exec_state),
+            RuntimeType::Object(tys) => self.coerce_to_object_type(tys, exec_state),
+        }
+    }
+
+    fn coerce_to_primitive_type(&self, ty: &PrimitiveType, exec_state: &mut ExecState) -> Option<KclValue> {
+        let value = match self {
+            KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } if value.len() == 1 => &value[0],
+            _ => self,
+        };
+        match ty {
+            // TODO numeric type coercions
+            PrimitiveType::Number(_ty) => match value {
+                KclValue::Number { .. } => Some(value.clone()),
+                _ => None,
+            },
+            PrimitiveType::String => match value {
+                KclValue::String { .. } => Some(value.clone()),
+                _ => None,
+            },
+            PrimitiveType::Boolean => match value {
+                KclValue::Bool { .. } => Some(value.clone()),
+                _ => None,
+            },
+            PrimitiveType::Sketch => match value {
+                KclValue::Sketch { .. } => Some(value.clone()),
+                _ => None,
+            },
+            PrimitiveType::Solid => match value {
+                KclValue::Solid { .. } => Some(value.clone()),
+                _ => None,
+            },
+            PrimitiveType::Plane => match value {
+                KclValue::Plane { .. } => Some(value.clone()),
+                KclValue::Object { value, meta } => {
+                    let origin = value.get("origin").and_then(Point3d::from_kcl_val)?;
+                    let x_axis = value.get("xAxis").and_then(Point3d::from_kcl_val)?;
+                    let y_axis = value.get("yAxis").and_then(Point3d::from_kcl_val)?;
+                    let z_axis = value.get("zAxis").and_then(Point3d::from_kcl_val)?;
+
+                    let id = exec_state.mod_local.id_generator.next_uuid();
+                    let plane = Plane {
+                        id,
+                        artifact_id: id.into(),
+                        origin,
+                        x_axis,
+                        y_axis,
+                        z_axis,
+                        value: super::PlaneType::Uninit,
+                        // TODO use length unit from origin
+                        units: exec_state.length_unit(),
+                        meta: meta.clone(),
+                    };
+
+                    Some(KclValue::Plane { value: Box::new(plane) })
+                }
+                _ => None,
+            },
+            PrimitiveType::ImportedGeometry => match value {
+                KclValue::ImportedGeometry { .. } => Some(value.clone()),
+                _ => None,
+            },
+        }
+    }
+
+    fn coerce_to_array_type(&self, ty: &PrimitiveType, len: ArrayLen, exec_state: &mut ExecState) -> Option<KclValue> {
+        match self {
+            KclValue::HomArray { value, ty: aty } => {
+                // TODO could check types of values individually
+                if aty != ty {
+                    return None;
+                }
+
+                let value = match len {
+                    ArrayLen::None => value.clone(),
+                    ArrayLen::NonEmpty => {
+                        if value.is_empty() {
+                            return None;
+                        }
+
+                        value.clone()
+                    }
+                    ArrayLen::Known(n) => {
+                        if n != value.len() {
+                            return None;
+                        }
+
+                        value[..n].to_vec()
+                    }
+                };
+
+                Some(KclValue::HomArray { value, ty: ty.clone() })
+            }
+            KclValue::MixedArray { value, .. } => {
+                let value = match len {
+                    ArrayLen::None => value.clone(),
+                    ArrayLen::NonEmpty => {
+                        if value.is_empty() {
+                            return None;
+                        }
+
+                        value.clone()
+                    }
+                    ArrayLen::Known(n) => {
+                        if n != value.len() {
+                            return None;
+                        }
+
+                        value[..n].to_vec()
+                    }
+                };
+
+                let rt = RuntimeType::Primitive(ty.clone());
+                let value = value
+                    .iter()
+                    .map(|v| v.coerce(&rt, exec_state))
+                    .collect::<Option<Vec<_>>>()?;
+
+                Some(KclValue::HomArray { value, ty: ty.clone() })
+            }
+            KclValue::KclNone { .. } if len.satisfied(0) => Some(KclValue::HomArray {
+                value: Vec::new(),
+                ty: ty.clone(),
+            }),
+            value if len.satisfied(1) => {
+                if value.has_type(&RuntimeType::Primitive(ty.clone())) {
+                    Some(KclValue::HomArray {
+                        value: vec![value.clone()],
+                        ty: ty.clone(),
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn coerce_to_tuple_type(&self, tys: &[PrimitiveType], exec_state: &mut ExecState) -> Option<KclValue> {
+        match self {
+            KclValue::MixedArray { value, .. } | KclValue::HomArray { value, .. } => {
+                if value.len() < tys.len() {
+                    return None;
+                }
+                let mut result = Vec::new();
+                for (i, t) in tys.iter().enumerate() {
+                    result.push(value[i].coerce_to_primitive_type(t, exec_state)?);
+                }
+
+                Some(KclValue::MixedArray {
+                    value: result,
+                    meta: Vec::new(),
+                })
+            }
+            KclValue::KclNone { meta, .. } if tys.is_empty() => Some(KclValue::MixedArray {
+                value: Vec::new(),
+                meta: meta.clone(),
+            }),
+            value if tys.len() == 1 => {
+                if value.has_type(&RuntimeType::Primitive(tys[0].clone())) {
+                    Some(KclValue::MixedArray {
+                        value: vec![value.clone()],
+                        meta: Vec::new(),
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    }
+
+    fn coerce_to_union_type(&self, tys: &[RuntimeType], exec_state: &mut ExecState) -> Option<KclValue> {
+        for t in tys {
+            if let Some(v) = self.coerce(t, exec_state) {
+                return Some(v);
+            }
+        }
+
+        None
+    }
+
+    fn coerce_to_object_type(&self, tys: &[(String, RuntimeType)], _exec_state: &mut ExecState) -> Option<KclValue> {
+        match self {
+            KclValue::Object { value, .. } => {
+                for (s, t) in tys {
+                    // TODO coerce fields
+                    if !value.get(s)?.has_type(t) {
+                        return None;
+                    }
+                }
+                // TODO remove non-required fields
+                Some(self.clone())
+            }
+            _ => None,
+        }
+    }
+
     pub fn principal_type(&self) -> Option<RuntimeType> {
         match self {
             KclValue::Bool { .. } => Some(RuntimeType::Primitive(PrimitiveType::Boolean)),
@@ -608,26 +785,24 @@ impl KclValue {
             }
             KclValue::Plane { .. } => Some(RuntimeType::Primitive(PrimitiveType::Plane)),
             KclValue::Sketch { .. } => Some(RuntimeType::Primitive(PrimitiveType::Sketch)),
-            KclValue::Sketches { .. } => Some(RuntimeType::Array(PrimitiveType::Sketch)),
             KclValue::Solid { .. } => Some(RuntimeType::Primitive(PrimitiveType::Solid)),
-            KclValue::Solids { .. } => Some(RuntimeType::Array(PrimitiveType::Solid)),
+            KclValue::ImportedGeometry(..) => Some(RuntimeType::Primitive(PrimitiveType::ImportedGeometry)),
             KclValue::MixedArray { value, .. } => Some(RuntimeType::Tuple(
                 value
                     .iter()
                     .map(|v| v.principal_type().and_then(RuntimeType::primitive))
                     .collect::<Option<Vec<_>>>()?,
             )),
+            KclValue::HomArray { ty, value, .. } => Some(RuntimeType::Array(ty.clone(), ArrayLen::Known(value.len()))),
             KclValue::Face { .. } => None,
             KclValue::Helix { .. }
-            | KclValue::ImportedGeometry(..)
             | KclValue::Function { .. }
             | KclValue::Module { .. }
             | KclValue::TagIdentifier(_)
             | KclValue::TagDeclarator(_)
             | KclValue::KclNone { .. }
             | KclValue::Type { .. }
-            | KclValue::Uuid { .. }
-            | KclValue::Tombstone { .. } => None,
+            | KclValue::Uuid { .. } => None,
         }
     }
 
@@ -729,20 +904,18 @@ impl KclValue {
             KclValue::TagIdentifier(tag) => Some(format!("${}", tag.value)),
             // TODO better Array and Object stringification
             KclValue::MixedArray { .. } => Some("[...]".to_owned()),
+            KclValue::HomArray { .. } => Some("[...]".to_owned()),
             KclValue::Object { .. } => Some("{ ... }".to_owned()),
             KclValue::Module { .. }
             | KclValue::Solid { .. }
-            | KclValue::Solids { .. }
             | KclValue::Sketch { .. }
-            | KclValue::Sketches { .. }
             | KclValue::Helix { .. }
             | KclValue::ImportedGeometry(_)
             | KclValue::Function { .. }
             | KclValue::Plane { .. }
             | KclValue::Face { .. }
             | KclValue::KclNone { .. }
-            | KclValue::Type { .. }
-            | KclValue::Tombstone { .. } => None,
+            | KclValue::Type { .. } => None,
         }
     }
 }
@@ -750,7 +923,8 @@ impl KclValue {
 #[derive(Debug, Clone, PartialEq)]
 pub enum RuntimeType {
     Primitive(PrimitiveType),
-    Array(PrimitiveType),
+    Array(PrimitiveType, ArrayLen),
+    Union(Vec<RuntimeType>),
     Tuple(Vec<PrimitiveType>),
     Object(Vec<(String, RuntimeType)>),
 }
@@ -765,7 +939,9 @@ impl RuntimeType {
             Type::Primitive(pt) => {
                 PrimitiveType::from_parsed(pt, exec_state, source_range)?.map(RuntimeType::Primitive)
             }
-            Type::Array(pt) => PrimitiveType::from_parsed(pt, exec_state, source_range)?.map(RuntimeType::Array),
+            Type::Array(pt) => {
+                PrimitiveType::from_parsed(pt, exec_state, source_range)?.map(|t| RuntimeType::Array(t, ArrayLen::None))
+            }
             Type::Object { properties } => properties
                 .into_iter()
                 .map(|p| {
@@ -781,15 +957,37 @@ impl RuntimeType {
         })
     }
 
+    pub fn human_friendly_type(&self) -> String {
+        match self {
+            RuntimeType::Primitive(ty) => ty.to_string(),
+            RuntimeType::Array(ty, ArrayLen::None) => format!("an array of {}", ty.display_multiple()),
+            RuntimeType::Array(ty, ArrayLen::NonEmpty) => format!("one or more {}", ty.display_multiple()),
+            RuntimeType::Array(ty, ArrayLen::Known(n)) => format!("an array of {n} {}", ty.display_multiple()),
+            RuntimeType::Union(tys) => tys
+                .iter()
+                .map(Self::human_friendly_type)
+                .collect::<Vec<_>>()
+                .join(" or "),
+            RuntimeType::Tuple(tys) => format!(
+                "an array with values of types ({})",
+                tys.iter().map(PrimitiveType::to_string).collect::<Vec<_>>().join(", ")
+            ),
+            RuntimeType::Object(_) => format!("an object with fields {}", self),
+        }
+    }
+
     // Subtype with no coercion, including refining numeric types.
     fn subtype(&self, sup: &RuntimeType) -> bool {
         use RuntimeType::*;
 
         match (self, sup) {
+            (Primitive(t1), Primitive(t2)) => t1 == t2,
             // TODO arrays could be covariant
-            (Primitive(t1), Primitive(t2)) | (Array(t1), Array(t2)) => t1 == t2,
+            (Array(t1, l1), Array(t2, l2)) => t1 == t2 && l1.subtype(*l2),
             (Tuple(t1), Tuple(t2)) => t1 == t2,
-            (Tuple(t1), Array(t2)) => t1.iter().all(|t| t == t2),
+            (Tuple(t1), Array(t2, l2)) => (l2.satisfied(t1.len())) && t1.iter().all(|t| t == t2),
+            (Union(ts1), Union(ts2)) => ts1.iter().all(|t| ts2.contains(t)),
+            (t1, Union(ts2)) => ts2.contains(t1),
             // TODO record subtyping - subtype can be larger, fields can be covariant.
             (Object(t1), Object(t2)) => t1 == t2,
             _ => false,
@@ -808,12 +1006,21 @@ impl fmt::Display for RuntimeType {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             RuntimeType::Primitive(t) => t.fmt(f),
-            RuntimeType::Array(t) => write!(f, "[{t}]"),
+            RuntimeType::Array(t, l) => match l {
+                ArrayLen::None => write!(f, "[{t}]"),
+                ArrayLen::NonEmpty => write!(f, "[{t}; 1+]"),
+                ArrayLen::Known(n) => write!(f, "[{t}; {n}]"),
+            },
             RuntimeType::Tuple(ts) => write!(
                 f,
                 "[{}]",
                 ts.iter().map(|t| t.to_string()).collect::<Vec<_>>().join(", ")
             ),
+            RuntimeType::Union(ts) => write!(
+                f,
+                "{}",
+                ts.iter().map(|t| t.to_string()).collect::<Vec<_>>().join(" | ")
+            ),
             RuntimeType::Object(items) => write!(
                 f,
                 "{{ {} }}",
@@ -827,6 +1034,34 @@ impl fmt::Display for RuntimeType {
     }
 }
 
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ArrayLen {
+    None,
+    NonEmpty,
+    Known(usize),
+}
+
+impl ArrayLen {
+    pub fn subtype(self, other: ArrayLen) -> bool {
+        match (self, other) {
+            (_, ArrayLen::None) => true,
+            (ArrayLen::NonEmpty, ArrayLen::NonEmpty) => true,
+            (ArrayLen::Known(size), ArrayLen::NonEmpty) if size > 0 => true,
+            (ArrayLen::Known(s1), ArrayLen::Known(s2)) if s1 == s2 => true,
+            _ => false,
+        }
+    }
+
+    /// True if the length constraint is satisfied by the supplied length.
+    fn satisfied(self, len: usize) -> bool {
+        match self {
+            ArrayLen::None => true,
+            ArrayLen::NonEmpty => len > 0,
+            ArrayLen::Known(s) => len == s,
+        }
+    }
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub enum PrimitiveType {
     Number(NumericType),
@@ -835,6 +1070,7 @@ pub enum PrimitiveType {
     Sketch,
     Solid,
     Plane,
+    ImportedGeometry,
 }
 
 impl PrimitiveType {
@@ -866,6 +1102,19 @@ impl PrimitiveType {
             _ => None,
         })
     }
+
+    fn display_multiple(&self) -> String {
+        match self {
+            PrimitiveType::Number(NumericType::Known(unit)) => format!("numbers({unit})"),
+            PrimitiveType::Number(_) => "numbers".to_owned(),
+            PrimitiveType::String => "strings".to_owned(),
+            PrimitiveType::Boolean => "bools".to_owned(),
+            PrimitiveType::Sketch => "Sketches".to_owned(),
+            PrimitiveType::Solid => "Solids".to_owned(),
+            PrimitiveType::Plane => "Planes".to_owned(),
+            PrimitiveType::ImportedGeometry => "imported geometries".to_owned(),
+        }
+    }
 }
 
 impl fmt::Display for PrimitiveType {
@@ -878,6 +1127,7 @@ impl fmt::Display for PrimitiveType {
             PrimitiveType::Sketch => write!(f, "Sketch"),
             PrimitiveType::Solid => write!(f, "Solid"),
             PrimitiveType::Plane => write!(f, "Plane"),
+            PrimitiveType::ImportedGeometry => write!(f, "imported geometry"),
         }
     }
 }

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

@@ -6,18 +6,18 @@
 //! one per execution. It has no explicit support for caching between executions.
 //!
 //! Memory is mostly immutable (since KCL does not support mutation or reassignment). However, tags
-//! may change as code is executed and that mutates memory. Therefore,
+//! may change as code is executed and that mutates memory. Therefore to some extent,
 //! ProgramMemory supports mutability and does not rely on KCL's (mostly) immutable nature.
 //!
 //! ProgramMemory is observably monotonic, i.e., it only grows and even when we pop a stack frame,
 //! the frame is retained unless we can prove it is unreferenced. We remove some values which we
 //! know cannot be referenced, but we should in the future do better garbage collection (of values
-//!  and envs).
+//! and envs).
 //!
 //! ## Concepts
 //!
-//! There are three main moving parts for ProgramMemory: environments, snapshots, and stacks. I'll
-//! cover environments (and the call stack) first as if snapshots didn't exist, then describe snapshots.
+//! There are three main moving parts for ProgramMemory: environments, epochs, and stacks. I'll
+//! cover environments (and the call stack) first as if epochs didn't exist, then describe epochs.
 //!
 //! An environment is a set of bindings (i.e., a map from names to values). Environments handle
 //! both scoping and context switching. A new lexical scope means a new environment. Nesting of scopes
@@ -81,12 +81,25 @@
 //! temporally) the definition of `c`. (Note that although KCL does not permit mutation, objects
 //! can change due to the way tags are implemented).
 //!
-//! To make this work, when we save a reference to an enclosing scope we take a snapshot of memory at
-//! that point and save a reference to that snapshot. When we call a function, the parent of the new
-//! callee env is that snapshot, not the current version of the enclosing scope.
+//! To make this work, we have the concept of an epoch. An epoch is a simple, global, monotonic counter
+//! which is incremented at any significant moment in execution (we use the term snapshot). When a
+//! value is saved in memory we also save the epoch at which it was stored.
 //!
-//! Entering an inline scope (e.g., the body of an `if` statement) means pushing an env whose parent
-//! is the current env. We don't need to snapshot in this case.
+//! When we save a reference to an enclosing scope we take a snapshot and save that epoch as part of
+//! the reference. When we call a function, we use the epoch when it was defined to look up variables,
+//! ignoring any variables which have a creation time later than the saved epoch.
+//!
+//! Because the callee could create new variables (with a creation time of the current epoch) which
+//! the callee should be able to read, we can't simply check the epoch with the callees (and we'd need
+//! to maintain a stack of callee epochs for further calls, etc.). Instead a stack frame consists of
+//! a reference to an environment and an epoch at which reads should take place. When we call a function
+//! this creates a new env using the current epoch, and it's parent env (which is the enclosing scope
+//! of the function declaration) includes the epoch at which the function was declared.
+//!
+//! So far, this handles variables created after a function is declared, but does not handle mutation.
+//! Mutation must be handled internally in values, see for example `TagIdentifier`. It is suggested
+//! that objects rely on epochs for this. Since epochs are linked to the stack frame, only objects in
+//! the current stack frame should be mutated.
 //!
 //! ### Std
 //!
@@ -107,53 +120,17 @@
 //! Pushing and popping stack frames is straightforward. Most get/set/update operations don't touch
 //! the call stack other than the current env (updating tags on function return is the exception).
 //!
-//! Snapshots are maintained within an environment and are always specific to an environment. Snapshots
-//! must also have a parent reference (since they are logically a snapshot of all memory). This parent
-//! refers to a snapshot within the parent env. When a snapshot is created, we must create a snapshot
-//! object for each parent env. When using a snapshot we must check the parent snapshot whenever
-//! we check the parent env (and not the current version of the parent env).
-//!
-//! An environment will have many snapshots, they are kept in time order, and do not reference each
-//! other. (The parent of a snapshot is always in another env).
-//!
-//! A snapshot is created empty (we don't copy memory) and we use a copy-on-write design: when a
-//! value in an environment is modified, we copy the old version into the most recent snapshot (note
-//! that we never overwrite a value in the snapshot, if a value is modified multiple times, we want
-//! to keep the original version, not an intermediate one). Likewise, if we insert a new variable,
-//! we put a tombstone value in the snapshot.
-//!
-//! When we read from the current version of an environment, we simply read from the bindings in the
-//! env and ignore the snapshots. When we read from a snapshot, we first check the specific snapshot
-//! for the key, then check any newer snapshots, then finally check the env bindings.
-//!
-//! A minor optimisation is that when creating a snapshot, if the previous one is empty, then
-//! we can reuse that rather than creating a new one. Since we only create a snapshot when a function
-//! is declared and the function decl is immediately saved into the new snapshot, the empty snapshot
-//! optimisation only happens with parent snapshots (though if the env tree is deep this means we
-//! can save a lot of snapshots).
-//!
 //! ## Invariants
 //!
 //! There's obviously a bunch of invariants in this design, some are kinda obvious, some are limited
 //! in scope and are documented inline, here are some others:
 //!
-//! - The current env and all envs in the call stack are 'just envs', never a snapshot (we could
-//!   use just a ref to an env, rather than to a snapshot but this is pretty inconvenient, so just
-//!   know that the snapshot ref is always to the current version). Only the parent envs or saved refs
-//!   can be refs to snapshots.
 //! - We only ever write into the current env, never into any parent envs (though we can read from
 //!   both).
-//! - Therefore, there is no concept of writing into a snapshot, only reading from one.
-//! - The env ref saved with a function decl is always to a snapshot, never to the current version.
-//! - If there are no snapshots in an environment and it is no longer in the call stack, then there
-//!   are no references from function decls to the env (if it is the parent of an env with extant refs
-//!   then there would be snapshots in the child env and that implies there must be a snapshot in the
-//!   parent to be the parent of that snapshot).
+//! - We only ever write (or mutate) at the most recent epoch, never at an older one.
+//! - The env ref saved with a function decl is always to an historic epoch, never to the current one.
 //! - Since KCL does not have submodules and decls are not visible outside of a nested scope, all
 //!   references to variables in other modules must be in the root scope of a module.
-//! - Therefore, an active env must either be on the call stack, have snapshots, or be a root env. This
-//!   is however a conservative approximation since snapshots may exist even if there are no live
-//!   references to an env.
 //!
 //! ## Concurrency and thread-safety
 //!
@@ -227,7 +204,6 @@
 
 use std::{
     cell::UnsafeCell,
-    collections::HashMap,
     fmt,
     pin::Pin,
     sync::{
@@ -267,6 +243,7 @@ pub(crate) struct ProgramMemory {
     /// Statistics about the memory, should not be used for anything other than meta-info.
     pub(crate) stats: MemoryStats,
     next_stack_id: AtomicUsize,
+    epoch: AtomicUsize,
     write_lock: AtomicBool,
 }
 
@@ -307,7 +284,7 @@ impl fmt::Display for Stack {
             .call_stack
             .iter()
             .chain(Some(&self.current_env))
-            .map(|e| format!("EnvRef({}, {})", e.0, e.1 .0))
+            .map(|e| format!("EnvRef({}, {})", e.0, e.1))
             .collect();
         write!(f, "Stack {}\nstack frames:\n{}", self.id, stack.join("\n"))
     }
@@ -322,6 +299,7 @@ impl ProgramMemory {
             std: None,
             stats: MemoryStats::default(),
             next_stack_id: AtomicUsize::new(1),
+            epoch: AtomicUsize::new(1),
             write_lock: AtomicBool::new(false),
         })
     }
@@ -340,10 +318,12 @@ impl ProgramMemory {
             std: self.std,
             stats: MemoryStats::default(),
             next_stack_id: AtomicUsize::new(self.next_stack_id.load(Ordering::Relaxed)),
+            epoch: AtomicUsize::new(self.epoch.load(Ordering::Relaxed)),
             write_lock: AtomicBool::new(false),
         })
     }
 
+    /// Create a new stack object referencing this `ProgramMemory`.
     pub fn new_stack(self: Arc<Self>) -> Stack {
         let id = self.next_stack_id.fetch_add(1, Ordering::Relaxed);
         assert!(id > 0);
@@ -367,7 +347,7 @@ impl ProgramMemory {
         self.std.is_none()
     }
 
-    /// Get a value from a specific snapshot of the memory.
+    /// Get a value from a specific environment of the memory at a specific point in time.
     pub fn get_from(
         &self,
         var: &str,
@@ -438,7 +418,7 @@ impl ProgramMemory {
 
         let new_env = Environment::new(parent, is_root_env, owner);
         self.with_envs(|envs| {
-            let result = EnvironmentRef(envs.len(), SnapshotRef::none());
+            let result = EnvironmentRef(envs.len(), usize::MAX);
             // Note this might reallocate, which would hold the `with_envs` spin lock for way too long
             // so somehow we should make sure we don't do that (though honestly the chance of that
             // happening while another thread is waiting for the lock is pretty small).
@@ -490,23 +470,12 @@ impl ProgramMemory {
         })
     }
 
-    #[cfg(test)]
-    fn update_with_env(&self, key: &str, value: KclValue, env: usize, owner: usize) {
-        self.stats.mutation_count.fetch_add(1, Ordering::Relaxed);
-        self.get_env(env).insert_or_update(key.to_owned(), value, owner);
-    }
-
     /// Get a value from memory without checking for ownership of the env.
     ///
     /// This is not safe to use in general and should only be used if you have unique access to
     /// the `self` which is generally only true during testing.
     #[cfg(test)]
-    pub fn get_from_unchecked(
-        &self,
-        var: &str,
-        mut env_ref: EnvironmentRef,
-        source_range: SourceRange,
-    ) -> Result<&KclValue, KclError> {
+    pub fn get_from_unchecked(&self, var: &str, mut env_ref: EnvironmentRef) -> Result<&KclValue, KclError> {
         loop {
             let env = self.get_env(env_ref.index());
             env_ref = match env.get_unchecked(var, env_ref.1) {
@@ -518,7 +487,7 @@ impl ProgramMemory {
 
         Err(KclError::UndefinedValue(KclErrorDetails {
             message: format!("memory item key `{}` is not defined", var),
-            source_ranges: vec![source_range],
+            source_ranges: vec![],
         }))
     }
 }
@@ -544,6 +513,11 @@ impl Stack {
         stack
     }
 
+    /// Get the current (globally most recent) epoch.
+    pub fn current_epoch(&self) -> usize {
+        self.memory.epoch.load(Ordering::Relaxed)
+    }
+
     /// Push a new (standard KCL) stack frame on to the call stack.
     ///
     /// `parent` is the environment where the function being called is declared (not the caller's
@@ -577,7 +551,7 @@ impl Stack {
         // Rust functions shouldn't try to set or access anything in their environment, so don't
         // waste time and space on a new env. Using usize::MAX means we'll get an overflow if we
         // try to access anything rather than a silent error.
-        self.current_env = EnvironmentRef(usize::MAX, SnapshotRef::none());
+        self.current_env = EnvironmentRef(usize::MAX, 0);
     }
 
     /// Push a new stack frame on to the call stack with no connection to a parent environment.
@@ -596,7 +570,6 @@ impl Stack {
     /// SAFETY: the env must not be being used by another `Stack` since we'll move the env from
     /// read-only to owned.
     pub fn restore_env(&mut self, env: EnvironmentRef) {
-        assert!(env.1.is_none());
         self.call_stack.push(self.current_env);
         self.memory.get_env(env.index()).restore_owner(self.id);
         self.current_env = env;
@@ -642,25 +615,28 @@ impl Stack {
         }
 
         let mut old_env = self.memory.take_env(old);
+        if old_env.is_empty() {
+            return;
+        }
 
-        // Map of any old env refs to the current env.
-        let snapshot_map: HashMap<_, _> = old_env
-            .snapshot_parents()
-            .map(|(s, p)| (EnvironmentRef(old.0, s), (EnvironmentRef(self.current_env.0, p))))
-            .collect();
-
+        // Make a new scope so we override variables properly.
+        self.push_new_env_for_scope();
         // Move the variables in the popped env into the current env.
         let env = self.memory.get_env(self.current_env.index());
-        for (k, v) in old_env.as_mut().take_bindings() {
-            env.insert_or_update(k.clone(), v.map_env_ref(&snapshot_map), self.id);
+        for (k, (e, v)) in old_env.as_mut().take_bindings() {
+            env.insert(k, e, v.map_env_ref(old.0, self.current_env.0), self.id);
         }
     }
 
     /// Snapshot the current state of the memory.
     pub fn snapshot(&mut self) -> EnvironmentRef {
-        self.memory.stats.snapshot_count.fetch_add(1, Ordering::Relaxed);
-        let snapshot = env::snapshot(&self.memory, self.current_env, self.id);
-        EnvironmentRef(self.current_env.0, snapshot)
+        self.memory.stats.epoch_count.fetch_add(1, Ordering::Relaxed);
+
+        let env = self.memory.get_env(self.current_env.index());
+        env.mark_as_refed();
+
+        let prev_epoch = self.memory.epoch.fetch_add(1, Ordering::Relaxed);
+        EnvironmentRef(self.current_env.0, prev_epoch)
     }
 
     /// Add a value to the program memory (in the current scope). The value must not already exist.
@@ -675,16 +651,21 @@ impl Stack {
 
         self.memory.stats.mutation_count.fetch_add(1, Ordering::Relaxed);
 
-        env.insert(key, value, self.id);
+        env.insert(key, self.memory.epoch.load(Ordering::Relaxed), value, self.id);
 
         Ok(())
     }
 
-    pub fn insert_or_update(&mut self, key: String, value: KclValue) {
+    /// Update a variable in memory. `key` must exist in memory. If it doesn't, this function will panic
+    /// in debug builds and do nothing in release builds.
+    pub fn update(&mut self, key: &str, f: impl Fn(&mut KclValue, usize)) {
         self.memory.stats.mutation_count.fetch_add(1, Ordering::Relaxed);
-        self.memory
-            .get_env(self.current_env.index())
-            .insert_or_update(key, value, self.id);
+        self.memory.get_env(self.current_env.index()).update(
+            key,
+            f,
+            self.memory.epoch.load(Ordering::Relaxed),
+            self.id,
+        );
     }
 
     /// Get a value from the program memory.
@@ -693,38 +674,41 @@ impl Stack {
         self.memory.get_from(var, self.current_env, source_range, self.id)
     }
 
+    /// Whether the current frame of the stack contains a variable with the given name.
+    pub fn cur_frame_contains(&self, var: &str) -> bool {
+        let env = self.memory.get_env(self.current_env.index());
+        env.contains_key(var)
+    }
+
     /// Get a key from the first KCL (i.e., non-Rust) stack frame on the call stack.
-    pub fn get_from_call_stack(&self, key: &str, source_range: SourceRange) -> Result<&KclValue, KclError> {
+    pub fn get_from_call_stack(&self, key: &str, source_range: SourceRange) -> Result<(usize, &KclValue), KclError> {
         if !self.current_env.skip_env() {
-            return self.get(key, source_range);
+            return Ok((self.current_env.1, self.get(key, source_range)?));
         }
 
         for env in self.call_stack.iter().rev() {
             if !env.skip_env() {
-                return self.memory.get_from(key, *env, source_range, self.id);
+                return Ok((env.1, self.memory.get_from(key, *env, source_range, self.id)?));
             }
         }
 
         unreachable!("It can't be Rust frames all the way down");
     }
 
-    /// Iterate over all key/value pairs in the current environment which satisfy the provided
-    /// predicate.
-    pub fn find_all_in_current_env<'a>(
+    /// Iterate over all keys in the current environment which satisfy the provided predicate.
+    pub fn find_keys_in_current_env<'a>(
         &'a self,
         pred: impl Fn(&KclValue) -> bool + 'a,
-    ) -> impl Iterator<Item = (&'a String, &'a KclValue)> {
-        self.memory.find_all_in_env(self.current_env, pred, self.id)
+    ) -> impl Iterator<Item = &'a String> {
+        self.memory
+            .find_all_in_env(self.current_env, pred, self.id)
+            .map(|(k, _)| k)
     }
 
     /// Iterate over all key/value pairs in the specified environment which satisfy the provided
     /// predicate. `env` must either be read-only or owned by `self`.
-    pub fn find_all_in_env<'a>(
-        &'a self,
-        env: EnvironmentRef,
-        pred: impl Fn(&KclValue) -> bool + 'a,
-    ) -> impl Iterator<Item = (&'a String, &'a KclValue)> {
-        self.memory.find_all_in_env(env, pred, self.id)
+    pub fn find_all_in_env(&self, env: EnvironmentRef) -> impl Iterator<Item = (&String, &KclValue)> {
+        self.memory.find_all_in_env(env, |_| true, self.id)
     }
 
     /// Walk all values accessible from any environment in the call stack.
@@ -781,7 +765,7 @@ impl<'a> Iterator for CallStackIterator<'a> {
                     return next;
                 }
 
-                if let Some(env_ref) = self.stack.memory.get_env(self.cur_env.index()).parent(self.cur_env.1) {
+                if let Some(env_ref) = self.stack.memory.get_env(self.cur_env.index()).parent() {
                     self.cur_env = env_ref;
                     self.init_iter();
                 } else {
@@ -816,23 +800,32 @@ impl<'a> Iterator for CallStackIterator<'a> {
 #[cfg(test)]
 impl PartialEq for Stack {
     fn eq(&self, other: &Self) -> bool {
-        let vars: Vec<_> = self.find_all_in_current_env(|_| true).collect();
-        let vars_other: Vec<_> = other.find_all_in_current_env(|_| true).collect();
-        vars == vars_other
+        let vars: Vec<_> = self.find_keys_in_current_env(|_| true).collect();
+        let vars_other: Vec<_> = other.find_keys_in_current_env(|_| true).collect();
+        if vars != vars_other {
+            return false;
+        }
+
+        vars.iter()
+            .all(|k| self.get(k, SourceRange::default()).unwrap() == other.get(k, SourceRange::default()).unwrap())
     }
 }
 
-/// An index pointing to an environment at a point in time (either a snapshot or the current version, see the module docs).
+/// An index pointing to an environment at a point in time.
+///
+/// The first field indexes an environment, the second field is an epoch. An epoch of 0 is indicates
+/// a dummy, error, or placeholder env ref, an epoch of `usize::MAX` represents the current most
+/// recent epoch.
 #[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Hash, Eq, ts_rs::TS, JsonSchema)]
-pub struct EnvironmentRef(usize, SnapshotRef);
+pub struct EnvironmentRef(usize, usize);
 
 impl EnvironmentRef {
     fn dummy() -> Self {
-        Self(usize::MAX, SnapshotRef(usize::MAX))
+        Self(usize::MAX, 0)
     }
 
     fn is_regular(&self) -> bool {
-        self.0 < usize::MAX && self.1 .0 < usize::MAX
+        self.0 < usize::MAX && self.1 > 0
     }
 
     fn index(&self) -> usize {
@@ -842,33 +835,11 @@ impl EnvironmentRef {
     fn skip_env(&self) -> bool {
         self.0 == usize::MAX
     }
-}
 
-/// An index pointing to a snapshot within a specific (unspecified) environment.
-#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Hash, Eq, ts_rs::TS, JsonSchema)]
-struct SnapshotRef(usize);
-
-impl SnapshotRef {
-    /// Represents no snapshot, use the current version of the environment.
-    fn none() -> Self {
-        Self(0)
-    }
-
-    /// `self` represents a snapshot.
-    fn is_some(self) -> bool {
-        self.0 > 0
-    }
-
-    /// `self` represents the current version.
-    fn is_none(self) -> bool {
-        self.0 == 0
-    }
-
-    // Precondition: self.is_some()
-    fn index(&self) -> usize {
-        // Note that `0` is a distinguished value meaning 'no snapshot', so the reference value
-        // is one greater than the index into the list of snapshots.
-        self.0 - 1
+    pub fn replace_env(&mut self, old: usize, new: usize) {
+        if self.0 == old {
+            self.0 = new;
+        }
     }
 }
 
@@ -877,8 +848,8 @@ impl SnapshotRef {
 pub(crate) struct MemoryStats {
     // Total number of environments created.
     env_count: AtomicUsize,
-    // Total number of snapshots created.
-    snapshot_count: AtomicUsize,
+    // Total number of epochs.
+    epoch_count: AtomicUsize,
     // Total number of values inserted or updated.
     mutation_count: AtomicUsize,
     // The number of envs we delete when popped from the call stack.
@@ -900,12 +871,10 @@ mod env {
 
     #[derive(Debug)]
     pub(super) struct Environment {
-        bindings: UnsafeCell<IndexMap<String, KclValue>>,
-        // invariant: self.parent.is_none() => forall s in self.snapshots: s.parent_snapshot.is_none()
-        snapshots: UnsafeCell<Vec<Snapshot>>,
+        bindings: UnsafeCell<IndexMap<String, (usize, KclValue)>>,
         // An outer scope, if one exists.
         parent: Option<EnvironmentRef>,
-        is_root_env: bool,
+        might_be_refed: AtomicBool,
         // The id of the `Stack` if this `Environment` is on a call stack. If this is >0 then it may
         // only be read or written by that `Stack`; if 0 then the env is read-only.
         owner: AtomicUsize,
@@ -918,9 +887,8 @@ mod env {
             assert!(self.owner.load(Ordering::Acquire) == 0);
             Self {
                 bindings: UnsafeCell::new(self.get_bindings().clone()),
-                snapshots: UnsafeCell::new(self.iter_snapshots().cloned().collect()),
                 parent: self.parent,
-                is_root_env: self.is_root_env,
+                might_be_refed: AtomicBool::new(self.might_be_refed.load(Ordering::Acquire)),
                 owner: AtomicUsize::new(0),
                 _unpin: PhantomPinned,
             }
@@ -931,45 +899,19 @@ mod env {
         fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
             let parent = self
                 .parent
-                .map(|e| format!("EnvRef({}, {})", e.0, e.1 .0))
+                .map(|e| format!("EnvRef({}, {})", e.0, e.1))
                 .unwrap_or("_".to_owned());
             let data: Vec<String> = self
                 .get_bindings()
                 .iter()
-                .map(|(k, v)| format!("{k}: {}", v.human_friendly_type()))
+                .map(|(k, v)| format!("{k}: {}@{}", v.1.human_friendly_type(), v.0))
                 .collect();
-            let snapshots: Vec<String> = self.iter_snapshots().map(|s| s.to_string()).collect();
             write!(
                 f,
-                "Env {{\n  parent: {parent},\n  owner: {},\n  is root: {},\n  bindings:\n    {},\n  snapshots:\n    {}\n}}",
+                "Env {{\n  parent: {parent},\n  owner: {},\n  ref'ed?: {},\n  bindings:\n    {}\n}}",
                 self.owner.load(Ordering::Relaxed),
-                self.is_root_env,
+                self.might_be_refed.load(Ordering::Relaxed),
                 data.join("\n    "),
-                snapshots.join("\n    ")
-            )
-        }
-    }
-
-    #[derive(Debug, Clone, PartialEq)]
-    struct Snapshot {
-        /// The version of the owning environment's parent environment corresponding to this snapshot.
-        parent_snapshot: Option<SnapshotRef>,
-        /// CoW'ed data from the environment.
-        data: IndexMap<String, KclValue>,
-    }
-
-    impl fmt::Display for Snapshot {
-        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-            let parent = self.parent_snapshot.map(|s| s.0.to_string()).unwrap_or("_".to_owned());
-            let data: Vec<String> = self
-                .data
-                .iter()
-                .map(|(k, v)| format!("{k}: {}", v.human_friendly_type()))
-                .collect();
-            write!(
-                f,
-                "Snapshot {{\n      parent: {parent},\n      data: {},\n    }}",
-                data.join("\n        ")
             )
         }
     }
@@ -977,80 +919,47 @@ mod env {
     impl Environment {
         /// Create a new environment, parent points to it's surrounding lexical scope or the std
         /// env if it's a root scope.
-        pub(super) fn new(parent: Option<EnvironmentRef>, is_root_env: bool, owner: usize) -> Self {
+        pub(super) fn new(parent: Option<EnvironmentRef>, might_be_refed: bool, owner: usize) -> Self {
             assert!(parent.map(|p| p.is_regular()).unwrap_or(true));
             Self {
                 bindings: UnsafeCell::new(IndexMap::new()),
-                snapshots: UnsafeCell::new(Vec::new()),
                 parent,
-                is_root_env,
+                might_be_refed: AtomicBool::new(might_be_refed),
                 owner: AtomicUsize::new(owner),
                 _unpin: PhantomPinned,
             }
         }
 
-        // Mark this env as read-only (see module docs).
+        /// Mark this env as read-only (see module docs).
         pub(super) fn read_only(&self) {
             self.owner.store(0, Ordering::Release);
         }
 
-        // Mark this env as owned (see module docs).
+        /// Mark this env as owned (see module docs).
         pub(super) fn restore_owner(&self, owner: usize) {
             self.owner.store(owner, Ordering::Release);
         }
 
-        // SAFETY: either the owner of the env is on the Rust stack or the env is read-only.
-        fn snapshots_len(&self) -> usize {
-            unsafe { self.snapshots.get().as_ref().unwrap().len() }
+        /// Mark this environment as possibly having external references.
+        pub(super) fn mark_as_refed(&self) {
+            self.might_be_refed.store(true, Ordering::Release);
         }
 
         // SAFETY: either the owner of the env is on the Rust stack or the env is read-only.
-        fn get_shapshot(&self, index: usize) -> &Snapshot {
-            unsafe { &self.snapshots.get().as_ref().unwrap()[index] }
-        }
-
-        // SAFETY: either the owner of the env is on the Rust stack or the env is read-only.
-        fn iter_snapshots(&self) -> impl Iterator<Item = &Snapshot> {
-            unsafe { self.snapshots.get().as_ref().unwrap().iter() }
-        }
-
-        fn cur_snapshot(&self, owner: usize) -> Option<&mut Snapshot> {
-            assert!(owner > 0 && self.owner.load(Ordering::Acquire) == owner);
-            unsafe { self.snapshots.get().as_mut().unwrap().last_mut() }
-        }
-
-        // SAFETY: either the owner of the env is on the Rust stack or the env is read-only.
-        fn get_bindings(&self) -> &IndexMap<String, KclValue> {
+        fn get_bindings(&self) -> &IndexMap<String, (usize, KclValue)> {
             unsafe { self.bindings.get().as_ref().unwrap() }
         }
 
         // SAFETY do not call this function while a previous mutable reference is live
         #[allow(clippy::mut_from_ref)]
-        fn get_mut_bindings(&self, owner: usize) -> &mut IndexMap<String, KclValue> {
+        fn get_mut_bindings(&self, owner: usize) -> &mut IndexMap<String, (usize, KclValue)> {
             assert!(owner > 0 && self.owner.load(Ordering::Acquire) == owner);
             unsafe { self.bindings.get().as_mut().unwrap() }
         }
 
-        // True if the env is empty and not a root env.
+        // True if the env is empty and has no external references.
         pub(super) fn is_empty(&self) -> bool {
-            self.snapshots_len() == 0 && self.get_bindings().is_empty() && !self.is_root_env
-        }
-
-        fn push_snapshot(&self, parent: Option<SnapshotRef>, owner: usize) -> SnapshotRef {
-            let env_owner = self.owner.load(Ordering::Acquire);
-            // The env is read-only, no need to snapshot.
-            if env_owner == 0 {
-                return SnapshotRef::none();
-            }
-            assert!(
-                owner > 0 && env_owner == owner,
-                "mutating owner: {owner}, env: {self}({env_owner})"
-            );
-            unsafe {
-                let snapshots = self.snapshots.get().as_mut().unwrap();
-                snapshots.push(Snapshot::new(parent));
-                SnapshotRef(snapshots.len())
-            }
+            self.get_bindings().is_empty() && !self.might_be_refed.load(Ordering::Acquire)
         }
 
         /// Possibly compress this environment by deleting the memory.
@@ -1062,116 +971,61 @@ mod env {
         /// See module docs for more details.
         pub(super) fn compact(&self, owner: usize) {
             // Don't compress if there might be a closure or import referencing us.
-            if self.snapshots_len() != 0 || self.is_root_env {
+            if self.might_be_refed.load(Ordering::Acquire) {
                 return;
             }
 
             *self.get_mut_bindings(owner) = IndexMap::new();
         }
 
-        pub(super) fn get(
-            &self,
-            key: &str,
-            snapshot: SnapshotRef,
-            owner: usize,
-        ) -> Result<&KclValue, Option<EnvironmentRef>> {
+        pub(super) fn get(&self, key: &str, epoch: usize, owner: usize) -> Result<&KclValue, Option<EnvironmentRef>> {
             let env_owner = self.owner.load(Ordering::Acquire);
             assert!(env_owner == 0 || env_owner == owner);
 
-            self.get_unchecked(key, snapshot)
+            self.get_unchecked(key, epoch)
         }
 
         /// Get a value from memory without checking the env's ownership invariant. Prefer to use `get`.
-        pub(super) fn get_unchecked(
-            &self,
-            key: &str,
-            snapshot: SnapshotRef,
-        ) -> Result<&KclValue, Option<EnvironmentRef>> {
-            if snapshot.is_some() {
-                for i in snapshot.index()..self.snapshots_len() {
-                    match self.get_shapshot(i).data.get(key) {
-                        Some(KclValue::Tombstone { .. }) => return Err(self.parent(snapshot)),
-                        Some(v) => return Ok(v),
-                        None => {}
-                    }
-                }
-            }
-
+        pub(super) fn get_unchecked(&self, key: &str, epoch: usize) -> Result<&KclValue, Option<EnvironmentRef>> {
             self.get_bindings()
                 .get(key)
-                .and_then(|v| match v {
-                    KclValue::Tombstone { .. } => None,
-                    _ => Some(v),
-                })
-                .ok_or(self.parent(snapshot))
+                .and_then(|(e, v)| if *e <= epoch { Some(v) } else { None })
+                .ok_or(self.parent)
         }
 
-        /// Find the `EnvironmentRef` of the parent of this environment corresponding to the specified snapshot.
-        pub(super) fn parent(&self, snapshot: SnapshotRef) -> Option<EnvironmentRef> {
-            if snapshot.is_none() {
-                return self.parent;
-            }
+        pub(super) fn update(&self, key: &str, f: impl Fn(&mut KclValue, usize), epoch: usize, owner: usize) {
+            let Some((_, value)) = self.get_mut_bindings(owner).get_mut(key) else {
+                debug_assert!(false, "Missing memory entry for {key}");
+                return;
+            };
 
-            match self.get_shapshot(snapshot.index()).parent_snapshot {
-                Some(sr) => Some(EnvironmentRef(self.parent.unwrap().0, sr)),
-                None => self.parent,
-            }
+            f(value, epoch);
         }
 
-        /// Iterate over all values in the environment at the specified snapshot.
-        pub(super) fn values<'a>(&'a self, snapshot: SnapshotRef) -> Box<dyn Iterator<Item = &'a KclValue> + 'a> {
-            if snapshot.is_none() {
-                return Box::new(self.get_bindings().values());
-            }
+        pub(super) fn parent(&self) -> Option<EnvironmentRef> {
+            self.parent
+        }
 
+        /// Iterate over all values in the environment at the specified epoch.
+        pub(super) fn values<'a>(&'a self, epoch: usize) -> Box<dyn Iterator<Item = &'a KclValue> + 'a> {
             Box::new(
                 self.get_bindings()
-                    .iter()
-                    .filter_map(move |(k, v)| {
-                        (!self.snapshot_contains_key(k, snapshot) && !matches!(v, KclValue::Tombstone { .. }))
-                            .then_some(v)
-                    })
-                    .chain(
-                        self.iter_snapshots()
-                            .flat_map(|s| s.data.values().filter(|v| !matches!(v, KclValue::Tombstone { .. }))),
-                    ),
+                    .values()
+                    .filter_map(move |(e, v)| (*e <= epoch).then_some(v)),
             )
         }
 
         /// Pure insert, panics if `key` is already in this environment.
         ///
         /// Precondition: !self.contains_key(key)
-        pub(super) fn insert(&self, key: String, value: KclValue, owner: usize) {
+        pub(super) fn insert(&self, key: String, epoch: usize, value: KclValue, owner: usize) {
             debug_assert!(!self.get_bindings().contains_key(&key));
-            if let Some(s) = self.cur_snapshot(owner) {
-                s.data.insert(key.clone(), tombstone());
-            }
-            self.get_mut_bindings(owner).insert(key, value);
-        }
-
-        pub(super) fn insert_or_update(&self, key: String, value: KclValue, owner: usize) {
-            if let Some(s) = self.cur_snapshot(owner) {
-                if !s.data.contains_key(&key) {
-                    let old_value = self.get_bindings().get(&key).cloned().unwrap_or_else(tombstone);
-                    s.data.insert(key.clone(), old_value);
-                }
-            }
-            self.get_mut_bindings(owner).insert(key, value);
-        }
-
-        /// Was the key contained in this environment at the specified point in time.
-        fn snapshot_contains_key(&self, key: &str, snapshot: SnapshotRef) -> bool {
-            for i in snapshot.index()..self.snapshots_len() {
-                if self.get_shapshot(i).data.contains_key(key) {
-                    return true;
-                }
-            }
-            false
+            self.get_mut_bindings(owner).insert(key, (epoch, value));
         }
 
         /// Is the key currently contained in this environment.
         pub(super) fn contains_key(&self, key: &str) -> bool {
-            !matches!(self.get_bindings().get(key), Some(KclValue::Tombstone { .. }) | None)
+            self.get_bindings().contains_key(key)
         }
 
         /// Iterate over all key/value pairs currently in this environment where the value satisfies
@@ -1186,61 +1040,14 @@ mod env {
 
             self.get_bindings()
                 .iter()
-                .filter(move |(_, v)| f(v) && !matches!(v, KclValue::Tombstone { .. }))
+                .filter_map(move |(k, (_, v))| f(v).then_some((k, v)))
         }
 
         /// Take all bindings from the environment.
-        pub(super) fn take_bindings(self: Pin<&mut Self>) -> impl Iterator<Item = (String, KclValue)> {
+        pub(super) fn take_bindings(self: Pin<&mut Self>) -> impl Iterator<Item = (String, (usize, KclValue))> {
             // SAFETY: caller must have unique access since self is mut. We're not moving or invalidating `self`.
             let bindings = std::mem::take(unsafe { self.bindings.get().as_mut().unwrap() });
-            bindings
-                .into_iter()
-                .filter(move |(_, v)| !matches!(v, KclValue::Tombstone { .. }))
-        }
-
-        /// Returns an iterator over any snapshots in this environment, returning the ref to the
-        /// snapshot and its parent.
-        pub(super) fn snapshot_parents(&self) -> impl Iterator<Item = (SnapshotRef, SnapshotRef)> + '_ {
-            self.iter_snapshots()
-                .enumerate()
-                .map(|(i, s)| (SnapshotRef(i + 1), s.parent_snapshot.unwrap()))
-        }
-    }
-
-    impl Snapshot {
-        fn new(parent_snapshot: Option<SnapshotRef>) -> Self {
-            Snapshot {
-                parent_snapshot,
-                data: IndexMap::new(),
-            }
-        }
-    }
-
-    /// Build a new snapshot of the specified environment at the current moment.
-    ///
-    /// This is non-trival since we have to build the tree of parent snapshots.
-    pub(super) fn snapshot(mem: &ProgramMemory, env_ref: EnvironmentRef, owner: usize) -> SnapshotRef {
-        let env = mem.get_env(env_ref.index());
-        let parent_snapshot = env.parent.map(|p| snapshot(mem, p, owner));
-
-        let env = mem.get_env(env_ref.index());
-        if env.snapshots_len() == 0 {
-            return env.push_snapshot(parent_snapshot, owner);
-        }
-
-        let prev_snapshot = env.cur_snapshot(owner).unwrap();
-        if prev_snapshot.data.is_empty() && prev_snapshot.parent_snapshot == parent_snapshot {
-            // If the prev snapshot is empty, reuse it.
-            return SnapshotRef(env.snapshots_len());
-        }
-
-        env.push_snapshot(parent_snapshot, owner)
-    }
-
-    fn tombstone() -> KclValue {
-        KclValue::Tombstone {
-            value: (),
-            meta: Vec::new(),
+            bindings.into_iter()
         }
     }
 }
@@ -1270,16 +1077,9 @@ mod test {
         }
     }
 
-    fn expect_small_number(value: &KclValue) -> Option<i64> {
-        match value {
-            KclValue::Number { value, .. } if value > &0.0 && value < &10.0 => Some(*value as i64),
-            _ => None,
-        }
-    }
-
     #[track_caller]
     fn assert_get_from(mem: &Stack, key: &str, n: i64, snapshot: EnvironmentRef) {
-        match mem.memory.get_from_unchecked(key, snapshot, sr()).unwrap() {
+        match mem.memory.get_from_unchecked(key, snapshot).unwrap() {
             KclValue::Number { value, .. } => assert_eq!(*value as i64, n),
             _ => unreachable!(),
         }
@@ -1318,7 +1118,7 @@ mod test {
         assert_get(mem, "a", 1);
         mem.add("b".to_owned(), val(3), sr()).unwrap();
         assert_get(mem, "b", 3);
-        mem.memory.get_from_unchecked("b", sn, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("b", sn).unwrap_err();
     }
 
     #[test]
@@ -1337,11 +1137,11 @@ mod test {
         assert_get(mem, "b", 3);
         assert_get(mem, "c", 6);
         assert_get_from(mem, "a", 1, sn1);
-        mem.memory.get_from_unchecked("b", sn1, sr()).unwrap_err();
-        mem.memory.get_from_unchecked("c", sn1, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("b", sn1).unwrap_err();
+        mem.memory.get_from_unchecked("c", sn1).unwrap_err();
         assert_get_from(mem, "a", 1, sn2);
         assert_get_from(mem, "b", 3, sn2);
-        mem.memory.get_from_unchecked("c", sn2, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("c", sn2).unwrap_err();
     }
 
     #[test]
@@ -1481,7 +1281,7 @@ mod test {
 
         mem.pop_env();
         // old snapshot still untouched
-        mem.memory.get_from_unchecked("b", sn, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("b", sn).unwrap_err();
     }
 
     #[test]
@@ -1503,62 +1303,22 @@ mod test {
 
         mem.pop_env();
         // old snapshots still untouched
-        mem.memory.get_from_unchecked("b", sn1, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("b", sn1).unwrap_err();
         assert_get_from(mem, "b", 3, sn2);
-        mem.memory.get_from_unchecked("c", sn2, sr()).unwrap_err();
+        mem.memory.get_from_unchecked("c", sn2).unwrap_err();
         assert_get_from(mem, "b", 4, sn3);
-        mem.memory.get_from_unchecked("c", sn3, sr()).unwrap_err();
-    }
-
-    #[test]
-    fn snap_env_two_updates() {
-        let mem = &mut Stack::new_for_tests();
-        mem.add("a".to_owned(), val(1), sr()).unwrap();
-
-        let sn1 = mem.snapshot();
-        mem.add("b".to_owned(), val(3), sr()).unwrap();
-        let sn2 = mem.snapshot();
-
-        let callee_env = mem.current_env.0;
-        mem.push_new_env_for_call(sn2);
-        let sn3 = mem.snapshot();
-        mem.add("b".to_owned(), val(4), sr()).unwrap();
-        let sn4 = mem.snapshot();
-        mem.insert_or_update("b".to_owned(), val(6));
-        mem.memory.update_with_env("b", val(7), callee_env, mem.id);
-
-        assert_get(mem, "b", 6);
-        assert_get_from(mem, "b", 3, sn3);
-        assert_get_from(mem, "b", 4, sn4);
-
-        let vals: Vec<_> = mem.walk_call_stack().filter_map(expect_small_number).collect();
-        let expected = [6, 1, 3, 1, 7];
-        assert_eq!(vals, expected);
-
-        let popped = mem.pop_env();
-        assert_get(mem, "b", 7);
-        mem.memory.get_from_unchecked("b", sn1, sr()).unwrap_err();
-        assert_get_from(mem, "b", 3, sn2);
-
-        let vals: Vec<_> = mem.walk_call_stack().filter_map(expect_small_number).collect();
-        let expected = [1, 7];
-        assert_eq!(vals, expected);
-
-        let popped_env = mem.memory.get_env(popped.index());
-        let sp: Vec<_> = popped_env.snapshot_parents().collect();
-        assert_eq!(
-            sp,
-            vec![(SnapshotRef(1), SnapshotRef(2)), (SnapshotRef(2), SnapshotRef(2))]
-        );
+        mem.memory.get_from_unchecked("c", sn3).unwrap_err();
     }
 
     #[test]
     fn squash_env() {
         let mem = &mut Stack::new_for_tests();
         mem.add("a".to_owned(), val(1), sr()).unwrap();
+        mem.add("b".to_owned(), val(3), sr()).unwrap();
         let sn1 = mem.snapshot();
         mem.push_new_env_for_call(sn1);
         mem.add("b".to_owned(), val(2), sr()).unwrap();
+
         let sn2 = mem.snapshot();
         mem.add(
             "f".to_owned(),
@@ -1581,11 +1341,10 @@ mod test {
             KclValue::Function {
                 value: FunctionSource::User { memory, .. },
                 ..
-            } if memory == &sn1 => {}
-            v => panic!("{v:#?}"),
+            } if memory.0 == mem.current_env.0 => {}
+            v => panic!("{v:#?}, expected {sn1:?}"),
         }
-        assert_eq!(mem.memory.envs().len(), 1);
-        assert_eq!(mem.current_env, EnvironmentRef(0, SnapshotRef(0)));
+        assert_eq!(mem.memory.envs().len(), 2);
     }
 
     #[test]

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

@@ -10,6 +10,7 @@ use cache::OldAstState;
 pub use cache::{bust_cache, clear_mem_cache};
 pub use cad_op::Operation;
 pub use geometry::*;
+pub use id_generator::IdGenerator;
 pub(crate) use import::{
     import_foreign, send_to_engine as send_import_to_engine, PreImportedGeometry, ZOO_COORD_SYSTEM,
 };
@@ -25,7 +26,7 @@ use kittycad_modeling_cmds as kcmc;
 pub use memory::EnvironmentRef;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-pub use state::{ExecState, IdGenerator, MetaSettings};
+pub use state::{ExecState, MetaSettings};
 
 use crate::{
     engine::EngineManager,
@@ -49,6 +50,7 @@ pub(crate) mod cache;
 mod cad_op;
 mod exec_ast;
 mod geometry;
+mod id_generator;
 mod import;
 pub(crate) mod kcl_value;
 mod memory;
@@ -72,6 +74,8 @@ pub struct ExecOutcome {
     pub errors: Vec<CompilationError>,
     /// File Names in module Id array index order
     pub filenames: IndexMap<ModuleId, ModulePath>,
+    /// The default planes.
+    pub default_planes: Option<DefaultPlanes>,
 }
 
 #[derive(Debug, Default, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
@@ -91,11 +95,46 @@ pub struct DefaultPlanes {
 #[serde(tag = "type", rename_all = "camelCase")]
 pub struct TagIdentifier {
     pub value: String,
-    pub info: Option<TagEngineInfo>,
+    // Multi-version representation of info about the tag. Kept ordered. The usize is the epoch at which the info
+    // was written. Note that there might be multiple versions of tag info from the same epoch, the version with
+    // the higher index will be the most recent.
+    #[serde(skip)]
+    pub info: Vec<(usize, TagEngineInfo)>,
     #[serde(skip)]
     pub meta: Vec<Metadata>,
 }
 
+impl TagIdentifier {
+    /// Get the tag info for this tag at a specified epoch.
+    pub fn get_info(&self, at_epoch: usize) -> Option<&TagEngineInfo> {
+        for (e, info) in self.info.iter().rev() {
+            if *e <= at_epoch {
+                return Some(info);
+            }
+        }
+
+        None
+    }
+
+    /// Get the most recent tag info for this tag.
+    pub fn get_cur_info(&self) -> Option<&TagEngineInfo> {
+        self.info.last().map(|i| &i.1)
+    }
+
+    /// Add info from a different instance of this tag.
+    pub fn merge_info(&mut self, other: &TagIdentifier) {
+        assert_eq!(&self.value, &other.value);
+        'new_info: for (oe, ot) in &other.info {
+            for (e, _) in &self.info {
+                if e > oe {
+                    continue 'new_info;
+                }
+            }
+            self.info.push((*oe, ot.clone()));
+        }
+    }
+}
+
 impl Eq for TagIdentifier {}
 
 impl std::fmt::Display for TagIdentifier {
@@ -110,7 +149,7 @@ impl std::str::FromStr for TagIdentifier {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         Ok(Self {
             value: s.to_string(),
-            info: None,
+            info: Vec::new(),
             meta: Default::default(),
         })
     }
@@ -367,22 +406,14 @@ impl ExecutorContext {
     }
 
     #[cfg(target_arch = "wasm32")]
-    pub async fn new(
-        engine_manager: crate::engine::conn_wasm::EngineCommandManager,
-        fs_manager: crate::fs::wasm::FileSystemManager,
-        settings: ExecutorSettings,
-    ) -> Result<Self, String> {
-        Ok(ExecutorContext {
-            engine: Arc::new(Box::new(
-                crate::engine::conn_wasm::EngineConnection::new(engine_manager)
-                    .await
-                    .map_err(|e| format!("{:?}", e))?,
-            )),
-            fs: Arc::new(FileManager::new(fs_manager)),
+    pub fn new(engine: Arc<Box<dyn EngineManager>>, fs: Arc<FileManager>, settings: ExecutorSettings) -> Self {
+        ExecutorContext {
+            engine,
+            fs,
             stdlib: Arc::new(StdLib::new()),
             settings,
             context_type: ContextType::Live,
-        })
+        }
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -399,21 +430,14 @@ impl ExecutorContext {
     }
 
     #[cfg(target_arch = "wasm32")]
-    pub async fn new_mock(
-        fs_manager: crate::fs::wasm::FileSystemManager,
-        settings: ExecutorSettings,
-    ) -> Result<Self, String> {
-        Ok(ExecutorContext {
-            engine: Arc::new(Box::new(
-                crate::engine::conn_mock::EngineConnection::new()
-                    .await
-                    .map_err(|e| format!("{:?}", e))?,
-            )),
-            fs: Arc::new(FileManager::new(fs_manager)),
+    pub fn new_mock(engine: Arc<Box<dyn EngineManager>>, fs: Arc<FileManager>, settings: ExecutorSettings) -> Self {
+        ExecutorContext {
+            engine,
+            fs,
             stdlib: Arc::new(StdLib::new()),
             settings,
             context_type: ContextType::Mock,
-        })
+        }
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -499,7 +523,7 @@ impl ExecutorContext {
         source_range: crate::execution::SourceRange,
     ) -> Result<(), KclError> {
         self.engine
-            .clear_scene(&mut exec_state.global.id_generator, source_range)
+            .clear_scene(&mut exec_state.mod_local.id_generator, source_range)
             .await
     }
 
@@ -518,7 +542,7 @@ impl ExecutorContext {
     ) -> Result<ExecOutcome, KclErrorWithOutputs> {
         assert!(self.is_mock());
 
-        let mut exec_state = ExecState::new(&self.settings);
+        let mut exec_state = ExecState::new(self);
         if use_prev_memory {
             match cache::read_old_memory().await {
                 Some(mem) => *exec_state.mut_stack() = mem,
@@ -539,7 +563,7 @@ impl ExecutorContext {
         // memory, not to the exec_state which is not cached for mock execution.
 
         let mut mem = exec_state.stack().clone();
-        let outcome = exec_state.to_mock_wasm_outcome(result.0);
+        let outcome = exec_state.to_mock_wasm_outcome(result.0).await;
 
         mem.squash_env(result.0);
         cache::write_old_memory(mem).await;
@@ -607,13 +631,13 @@ impl ExecutorContext {
                         })
                         .await;
 
-                        let outcome = old_state.to_wasm_outcome(result_env);
+                        let outcome = old_state.to_wasm_outcome(result_env).await;
                         return Ok(outcome);
                     }
                     (true, program)
                 }
                 CacheResult::NoAction(false) => {
-                    let outcome = old_state.to_wasm_outcome(result_env);
+                    let outcome = old_state.to_wasm_outcome(result_env).await;
                     return Ok(outcome);
                 }
             };
@@ -621,7 +645,7 @@ impl ExecutorContext {
             let (exec_state, preserve_mem) = if clear_scene {
                 // Pop the execution state, since we are starting fresh.
                 let mut exec_state = old_state;
-                exec_state.reset(&self.settings);
+                exec_state.reset(self);
 
                 // We don't do this in mock mode since there is no engine connection
                 // anyways and from the TS side we override memory and don't want to clear it.
@@ -638,7 +662,7 @@ impl ExecutorContext {
 
             (program, exec_state, preserve_mem)
         } else {
-            let mut exec_state = ExecState::new(&self.settings);
+            let mut exec_state = ExecState::new(self);
             self.send_clear_scene(&mut exec_state, Default::default())
                 .await
                 .map_err(KclErrorWithOutputs::no_outputs)?;
@@ -663,7 +687,7 @@ impl ExecutorContext {
         })
         .await;
 
-        let outcome = exec_state.to_wasm_outcome(result.0);
+        let outcome = exec_state.to_wasm_outcome(result.0).await;
         Ok(outcome)
     }
 
@@ -699,6 +723,7 @@ impl ExecutorContext {
             .await
             .map_err(KclErrorWithOutputs::no_outputs)?;
 
+        let default_planes = self.engine.get_default_planes().read().await.clone();
         let env_ref = self
             .execute_and_build_graph(&program.ast, exec_state, preserve_mem)
             .await
@@ -717,6 +742,7 @@ impl ExecutorContext {
                     exec_state.global.artifact_graph.clone(),
                     module_id_to_module_path,
                     exec_state.global.id_to_source.clone(),
+                    default_planes,
                 )
             })?;
 
@@ -724,6 +750,7 @@ impl ExecutorContext {
             "Post interpretation KCL memory stats: {:#?}",
             exec_state.stack().memory.stats
         ));
+        crate::log::log(format!("Engine stats: {:?}", self.engine.stats()));
 
         if !self.is_mock() {
             let mut mem = exec_state.stack().deep_clone();
@@ -754,6 +781,7 @@ impl ExecutorContext {
                 exec_state,
                 ExecutionKind::Normal,
                 preserve_mem,
+                ModuleId::default(),
                 &ModulePath::Main,
             )
             .await;
@@ -933,7 +961,7 @@ pub(crate) async fn parse_execute(code: &str) -> Result<ExecTestResults, KclErro
         settings: Default::default(),
         context_type: ContextType::Mock,
     };
-    let mut exec_state = ExecState::new(&exec_ctxt.settings);
+    let mut exec_state = ExecState::new(&exec_ctxt);
     let result = exec_ctxt.run(&program, &mut exec_state).await?;
 
     Ok(ExecTestResults {
@@ -963,11 +991,7 @@ mod tests {
     /// Convenience function to get a JSON value from memory and unwrap.
     #[track_caller]
     fn mem_get_json(memory: &Stack, env: EnvironmentRef, name: &str) -> KclValue {
-        memory
-            .memory
-            .get_from_unchecked(name, env, SourceRange::default())
-            .unwrap()
-            .to_owned()
+        memory.memory.get_from_unchecked(name, env).unwrap().to_owned()
     }
 
     #[tokio::test(flavor = "multi_thread")]
@@ -1849,15 +1873,6 @@ let w = f() + f()
         parse_execute(ast).await.unwrap();
     }
 
-    #[test]
-    fn test_serialize_memory_item() {
-        let mem = KclValue::Solids {
-            value: Default::default(),
-        };
-        let json = serde_json::to_string(&mem).unwrap();
-        assert_eq!(json, r#"{"type":"Solids","value":[]}"#);
-    }
-
     #[tokio::test(flavor = "multi_thread")]
     async fn kcl_test_ids_stable_between_executions() {
         let code = r#"sketch001 = startSketchOn(XZ)
@@ -1880,10 +1895,14 @@ let w = f() + f()
         let old_program = crate::Program::parse_no_errs(code).unwrap();
 
         // Execute the program.
-        ctx.run_with_caching(old_program).await.unwrap();
+        if let Err(err) = ctx.run_with_caching(old_program).await {
+            let report = err.into_miette_report_with_outputs(code).unwrap();
+            let report = miette::Report::new(report);
+            panic!("Error executing program: {:?}", report);
+        }
 
         // Get the id_generator from the first execution.
-        let id_generator = cache::read_old_ast().await.unwrap().exec_state.global.id_generator;
+        let id_generator = cache::read_old_ast().await.unwrap().exec_state.mod_local.id_generator;
 
         let code = r#"sketch001 = startSketchOn(XZ)
 |> startProfileAt([62.74, 206.13], %)
@@ -1904,7 +1923,7 @@ let w = f() + f()
         // Execute the program.
         ctx.run_with_caching(program).await.unwrap();
 
-        let new_id_generator = cache::read_old_ast().await.unwrap().exec_state.global.id_generator;
+        let new_id_generator = cache::read_old_ast().await.unwrap().exec_state.mod_local.id_generator;
 
         assert_eq!(id_generator, new_id_generator);
     }
@@ -1933,7 +1952,6 @@ let w = f() + f()
         // Execute the program.
         ctx.run_with_caching(old_program.clone()).await.unwrap();
 
-        // Get the id_generator from the first execution.
         let settings_state = cache::read_old_ast().await.unwrap().settings;
 
         // Ensure the settings are as expected.
@@ -1945,7 +1963,6 @@ let w = f() + f()
         // Execute the program.
         ctx.run_with_caching(old_program.clone()).await.unwrap();
 
-        // Get the id_generator from the first execution.
         let settings_state = cache::read_old_ast().await.unwrap().settings;
 
         // Ensure the settings are as expected.
@@ -1957,7 +1974,6 @@ let w = f() + f()
         // Execute the program.
         ctx.run_with_caching(old_program).await.unwrap();
 
-        // Get the id_generator from the first execution.
         let settings_state = cache::read_old_ast().await.unwrap().settings;
 
         // Ensure the settings are as expected.
@@ -1976,4 +1992,41 @@ let w = f() + f()
         let result = ctx2.run_mock(program2, true).await.unwrap();
         assert_eq!(result.variables.get("z").unwrap().as_f64().unwrap(), 3.0);
     }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn read_tag_version() {
+        let ast = r#"fn bar(t) {
+  return startSketchOn(XY)
+    |> startProfileAt([0,0], %)
+    |> angledLine({
+        angle = -60,
+        length = segLen(t),
+    }, %)
+    |> line(end = [0, 0])
+    |> close()
+}
+  
+sketch = startSketchOn(XY)
+  |> startProfileAt([0,0], %)
+  |> line(end = [0, 10])
+  |> line(end = [10, 0], tag = $tag0)
+  |> line(end = [0, 0])
+
+fn foo() {
+  // tag0 tags an edge
+  return bar(tag0)
+}
+
+solid = sketch |> extrude(length = 10)
+// tag0 tags a face
+sketch2 = startSketchOn(solid, tag0)
+  |> startProfileAt([0,0], %)
+  |> line(end = [0, 1])
+  |> line(end = [1, 0])
+  |> line(end = [0, 0])
+
+foo() |> extrude(length = 1)
+"#;
+        parse_execute(ast).await.unwrap();
+    }
 }

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

@@ -10,7 +10,9 @@ use uuid::Uuid;
 use crate::{
     errors::{KclError, KclErrorDetails, Severity},
     execution::{
-        annotations, kcl_value,
+        annotations,
+        id_generator::IdGenerator,
+        kcl_value,
         memory::{ProgramMemory, Stack},
         Artifact, ArtifactCommand, ArtifactGraph, ArtifactId, EnvironmentRef, ExecOutcome, ExecutorSettings, KclValue,
         Operation, UnitAngle, UnitLen,
@@ -26,12 +28,11 @@ use crate::{
 pub struct ExecState {
     pub(super) global: GlobalState,
     pub(super) mod_local: ModuleState,
+    pub(super) exec_context: Option<super::ExecutorContext>,
 }
 
 #[derive(Debug, Clone)]
 pub(super) struct GlobalState {
-    /// The stable artifact ID generator.
-    pub id_generator: IdGenerator,
     /// Map from source file absolute path to module ID.
     pub path_to_source_id: IndexMap<ModulePath, ModuleId>,
     /// Map from module ID to source file.
@@ -62,6 +63,8 @@ pub(super) struct GlobalState {
 
 #[derive(Debug, Clone)]
 pub(super) struct ModuleState {
+    /// The id generator for this module.
+    pub id_generator: IdGenerator,
     pub stack: Stack,
     /// The current value of the pipe operator returned from the previous
     /// expression.  If we're not currently in a pipeline, this will be None.
@@ -73,25 +76,21 @@ pub(super) struct ModuleState {
 }
 
 impl ExecState {
-    pub fn new(exec_settings: &ExecutorSettings) -> Self {
+    pub fn new(exec_context: &super::ExecutorContext) -> Self {
         ExecState {
-            global: GlobalState::new(exec_settings),
-            mod_local: ModuleState::new(exec_settings, None, ProgramMemory::new()),
+            global: GlobalState::new(&exec_context.settings),
+            mod_local: ModuleState::new(&exec_context.settings, None, ProgramMemory::new(), Default::default()),
+            exec_context: Some(exec_context.clone()),
         }
     }
 
-    pub(super) fn reset(&mut self, exec_settings: &ExecutorSettings) {
-        let mut id_generator = self.global.id_generator.clone();
-        // We do not pop the ids, since we want to keep the same id generator.
-        // This is for the front end to keep track of the ids.
-        id_generator.next_id = 0;
-
-        let mut global = GlobalState::new(exec_settings);
-        global.id_generator = id_generator;
+    pub(super) fn reset(&mut self, exec_context: &super::ExecutorContext) {
+        let global = GlobalState::new(&exec_context.settings);
 
         *self = ExecState {
             global,
-            mod_local: ModuleState::new(exec_settings, None, ProgramMemory::new()),
+            mod_local: ModuleState::new(&exec_context.settings, None, ProgramMemory::new(), Default::default()),
+            exec_context: Some(exec_context.clone()),
         };
     }
 
@@ -113,13 +112,13 @@ impl ExecState {
     /// Convert to execution outcome when running in WebAssembly.  We want to
     /// reduce the amount of data that crosses the WASM boundary as much as
     /// possible.
-    pub fn to_wasm_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
+    pub async fn to_wasm_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
         // Fields are opt-in so that we don't accidentally leak private internal
         // state when we add more to ExecState.
         ExecOutcome {
             variables: self
                 .stack()
-                .find_all_in_env(main_ref, |_| true)
+                .find_all_in_env(main_ref)
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect(),
             operations: self.global.operations,
@@ -132,16 +131,21 @@ impl ExecState {
                 .iter()
                 .map(|(k, v)| ((*v), k.clone()))
                 .collect(),
+            default_planes: if let Some(ctx) = &self.exec_context {
+                ctx.engine.get_default_planes().read().await.clone()
+            } else {
+                None
+            },
         }
     }
 
-    pub fn to_mock_wasm_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
+    pub async fn to_mock_wasm_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
         // Fields are opt-in so that we don't accidentally leak private internal
         // state when we add more to ExecState.
         ExecOutcome {
             variables: self
                 .stack()
-                .find_all_in_env(main_ref, |_| true)
+                .find_all_in_env(main_ref)
                 .map(|(k, v)| (k.clone(), v.clone()))
                 .collect(),
             operations: Default::default(),
@@ -149,6 +153,11 @@ impl ExecState {
             artifact_graph: Default::default(),
             errors: self.global.errors,
             filenames: Default::default(),
+            default_planes: if let Some(ctx) = &self.exec_context {
+                ctx.engine.get_default_planes().read().await.clone()
+            } else {
+                None
+            },
         }
     }
 
@@ -160,8 +169,12 @@ impl ExecState {
         &mut self.mod_local.stack
     }
 
-    pub(crate) fn next_uuid(&mut self) -> Uuid {
-        self.global.id_generator.next_uuid()
+    pub fn next_uuid(&mut self) -> Uuid {
+        self.mod_local.id_generator.next_uuid()
+    }
+
+    pub fn id_generator(&mut self) -> &mut IdGenerator {
+        &mut self.mod_local.id_generator
     }
 
     pub(crate) fn add_artifact(&mut self, artifact: Artifact) {
@@ -241,7 +254,6 @@ impl ExecState {
 impl GlobalState {
     fn new(settings: &ExecutorSettings) -> Self {
         let mut global = GlobalState {
-            id_generator: Default::default(),
             path_to_source_id: Default::default(),
             module_infos: Default::default(),
             artifacts: Default::default(),
@@ -274,8 +286,14 @@ impl GlobalState {
 }
 
 impl ModuleState {
-    pub(super) fn new(exec_settings: &ExecutorSettings, std_path: Option<String>, memory: Arc<ProgramMemory>) -> Self {
+    pub(super) fn new(
+        exec_settings: &ExecutorSettings,
+        std_path: Option<String>,
+        memory: Arc<ProgramMemory>,
+        module_id: Option<ModuleId>,
+    ) -> Self {
         ModuleState {
+            id_generator: IdGenerator::new(module_id),
             stack: memory.new_stack(),
             pipe_value: Default::default(),
             module_exports: Default::default(),
@@ -332,29 +350,3 @@ impl MetaSettings {
         Ok(())
     }
 }
-
-/// A generator for ArtifactIds that can be stable across executions.
-#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
-#[serde(rename_all = "camelCase")]
-pub struct IdGenerator {
-    pub(super) next_id: usize,
-    ids: Vec<uuid::Uuid>,
-}
-
-impl IdGenerator {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    pub fn next_uuid(&mut self) -> uuid::Uuid {
-        if let Some(id) = self.ids.get(self.next_id) {
-            self.next_id += 1;
-            *id
-        } else {
-            let id = uuid::Uuid::new_v4();
-            self.ids.push(id);
-            self.next_id += 1;
-            id
-        }
-    }
-}

rust/kcl-lib/src/lib.rs

@@ -8,11 +8,11 @@
 #[allow(unused_macros)]
 macro_rules! println {
     ($($rest:tt)*) => {
-        #[cfg(feature = "disable-println")]
+        #[cfg(all(feature = "disable-println", not(test)))]
         {
             let _ = format!($($rest)*);
         }
-        #[cfg(not(feature = "disable-println"))]
+        #[cfg(any(not(feature = "disable-println"), test))]
         std::println!($($rest)*)
     }
 }
@@ -20,11 +20,11 @@ macro_rules! println {
 #[allow(unused_macros)]
 macro_rules! eprintln {
     ($($rest:tt)*) => {
-        #[cfg(feature = "disable-println")]
+        #[cfg(all(feature = "disable-println", not(test)))]
         {
             let _ = format!($($rest)*);
         }
-        #[cfg(not(feature = "disable-println"))]
+        #[cfg(any(not(feature = "disable-println"), test))]
         std::eprintln!($($rest)*)
     }
 }
@@ -32,11 +32,11 @@ macro_rules! eprintln {
 #[allow(unused_macros)]
 macro_rules! print {
     ($($rest:tt)*) => {
-        #[cfg(feature = "disable-println")]
+        #[cfg(all(feature = "disable-println", not(test)))]
         {
             let _ = format!($($rest)*);
         }
-        #[cfg(not(feature = "disable-println"))]
+        #[cfg(any(not(feature = "disable-println"), test))]
         std::print!($($rest)*)
     }
 }
@@ -44,11 +44,11 @@ macro_rules! print {
 #[allow(unused_macros)]
 macro_rules! eprint {
     ($($rest:tt)*) => {
-        #[cfg(feature = "disable-println")]
+        #[cfg(all(feature = "disable-println", not(test)))]
         {
             let _ = format!($($rest)*);
         }
-        #[cfg(not(feature = "disable-println"))]
+        #[cfg(any(not(feature = "disable-println"), test))]
         std::eprint!($($rest)*)
     }
 }
@@ -81,7 +81,7 @@ mod walk;
 mod wasm;
 
 pub use coredump::CoreDump;
-pub use engine::{EngineManager, ExecutionKind};
+pub use engine::{EngineManager, EngineStats, ExecutionKind};
 pub use errors::{
     CompilationError, ConnectionError, ExecError, KclError, KclErrorWithOutputs, Report, ReportWithOutputs,
 };
@@ -96,6 +96,8 @@ pub use modules::ModuleId;
 pub use parsing::ast::{modify::modify_ast_for_sketch, types::FormatOptions};
 pub use settings::types::{project::ProjectConfiguration, Configuration, UnitLength};
 pub use source_range::SourceRange;
+#[cfg(not(target_arch = "wasm32"))]
+pub use unparser::recast_dir;
 
 // Rather than make executor public and make lots of it pub(crate), just re-export into a new module.
 // Ideally we wouldn't export these things at all, they should only be used for testing.
@@ -108,10 +110,14 @@ pub mod wasm_engine {
     pub use crate::{
         coredump::wasm::{CoreDumpManager, CoreDumper},
         engine::conn_wasm::{EngineCommandManager, EngineConnection},
-        fs::wasm::FileSystemManager,
+        fs::wasm::{FileManager, FileSystemManager},
     };
 }
 
+pub mod mock_engine {
+    pub use crate::engine::conn_mock::EngineConnection;
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub mod native_engine {
     pub use crate::engine::conn::EngineConnection;

rust/kcl-lib/src/log.rs

@@ -36,7 +36,7 @@ macro_rules! logln {
 }
 pub(crate) use logln;
 
-#[cfg(all(not(feature = "disable-println"), not(target_arch = "wasm32")))]
+#[cfg(any(test, all(not(feature = "disable-println"), not(target_arch = "wasm32"))))]
 #[inline]
 fn log_inner(msg: String) {
     eprintln!("{msg}");
@@ -48,7 +48,7 @@ fn log_inner(msg: String) {
     web_sys::console::log_1(&msg.into());
 }
 
-#[cfg(feature = "disable-println")]
+#[cfg(all(feature = "disable-println", not(test)))]
 #[inline]
 fn log_inner(_msg: String) {}
 

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

@@ -1170,7 +1170,7 @@ impl LanguageServer for Backend {
             Hover::Variable { name, ty: None, range } => Ok(with_cached_var(&name, |value| {
                 let mut text: String = format!("```\n{}", name);
                 if let Some(ty) = value.principal_type() {
-                    text.push_str(&format!(": {}", ty));
+                    text.push_str(&format!(": {}", ty.human_friendly_type()));
                 }
                 if let Some(v) = value.value_str() {
                     text.push_str(&format!(" = {}", v));

rust/kcl-lib/src/main.rs

@@ -11,7 +11,13 @@ use kcl_lib::{ExecState, ExecutorContext, ExecutorSettings, Program};
 async fn main() {
     let mut args = env::args();
     args.next();
-    let filename = args.next().unwrap_or_else(|| "main.kcl".to_owned());
+    let mut filename = args.next().unwrap_or_else(|| "main.kcl".to_owned());
+    if !filename.ends_with(".kcl") {
+        if !filename.ends_with('/') && !filename.ends_with('\\') {
+            filename += "/";
+        }
+        filename += "main.kcl";
+    }
 
     let mut f = File::open(&filename).unwrap();
     let mut text = String::new();
@@ -36,6 +42,6 @@ async fn main() {
     )
     .await
     .unwrap();
-    let mut exec_state = ExecState::new(&ctx.settings);
+    let mut exec_state = ExecState::new(&ctx);
     ctx.run(&program, &mut exec_state).await.unwrap();
 }

rust/kcl-lib/src/modules.rs

@@ -33,6 +33,12 @@ impl ModuleId {
     }
 }
 
+impl std::fmt::Display for ModuleId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 #[derive(Debug, Clone, Default)]
 pub(crate) struct ModuleLoader {
     /// The stack of import statements for detecting circular module imports.

rust/kcl-lib/src/parsing/ast/types/mod.rs

@@ -2149,7 +2149,7 @@ impl From<&Node<TagDeclarator>> for TagIdentifier {
     fn from(tag: &Node<TagDeclarator>) -> Self {
         TagIdentifier {
             value: tag.name.clone(),
-            info: None,
+            info: Vec::new(),
             meta: vec![Metadata {
                 source_range: tag.into(),
             }],
@@ -2937,7 +2937,7 @@ impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Type::Primitive(primitive_type) => primitive_type.fmt(f),
-            Type::Array(primitive_type) => write!(f, "{primitive_type}[]"),
+            Type::Array(primitive_type) => write!(f, "[{primitive_type}]"),
             Type::Object { properties } => {
                 write!(f, "{{")?;
                 let mut first = true;
@@ -3509,7 +3509,7 @@ const cylinder = startSketchOn('-XZ')
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_parse_type_args_array_on_functions() {
-        let some_program_string = r#"fn thing = (arg0: number[], arg1: string[], tag?: string) => {
+        let some_program_string = r#"fn thing = (arg0: [number], arg1: [string], tag?: string) => {
     return arg0
 }"#;
         let program = crate::parsing::top_level_parse(some_program_string).unwrap();
@@ -3540,7 +3540,7 @@ const cylinder = startSketchOn('-XZ')
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_parse_type_args_object_on_functions() {
-        let some_program_string = r#"fn thing = (arg0: number[], arg1: {thing: number, things: string[], more?: string}, tag?: string) => {
+        let some_program_string = r#"fn thing = (arg0: [number], arg1: {thing: number, things: [string], more?: string}, tag?: string) => {
     return arg0
 }"#;
         let module_id = ModuleId::default();
@@ -3594,7 +3594,7 @@ const cylinder = startSketchOn('-XZ')
                             56,
                             module_id,
                         ),
-                        type_: Some(Node::new(Type::Array(PrimitiveType::String), 58, 64, module_id)),
+                        type_: Some(Node::new(Type::Array(PrimitiveType::String), 59, 65, module_id)),
                         default_value: None,
                         labeled: true,
                         digest: None
@@ -3625,7 +3625,7 @@ const cylinder = startSketchOn('-XZ')
 
     #[tokio::test(flavor = "multi_thread")]
     async fn test_parse_return_type_on_functions() {
-        let some_program_string = r#"fn thing(): {thing: number, things: string[], more?: string} {
+        let some_program_string = r#"fn thing(): {thing: number, things: [string], more?: string} {
     return 1
 }"#;
         let module_id = ModuleId::default();
@@ -3675,7 +3675,7 @@ const cylinder = startSketchOn('-XZ')
                             34,
                             module_id,
                         ),
-                        type_: Some(Node::new(Type::Array(PrimitiveType::String), 36, 42, module_id)),
+                        type_: Some(Node::new(Type::Array(PrimitiveType::String), 37, 43, module_id)),
                         default_value: None,
                         labeled: true,
                         digest: None

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

@@ -2651,7 +2651,7 @@ fn argument_type(i: &mut TokenSlice) -> PResult<Node<Type>> {
             ))
         }),
         // Array types
-        (primitive_type, open_bracket, close_bracket).map(|(t, _, _)| Ok(t.map(Type::Array))),
+        (open_bracket, primitive_type, close_bracket).map(|(_, t, _)| Ok(t.map(Type::Array))),
         // Primitive types
         primitive_type.map(|t| Ok(t.map(Type::Primitive))),
     ))