merge main

stabilize test by allowing more time before clicking object

.github/workflows/e2e-tests.yml

@@ -289,17 +289,6 @@ jobs:
           - windows-latest-8-cores
         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-8-cores
-            isScheduled: true
-        # TODO: add ref here for main and latest release tag
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4

.husky/pre-commit

@@ -0,0 +1 @@
+npm run fmt

.husky/pre-push

@@ -1,4 +0,0 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
-
-npm run fmt-check

docs/kcl/getNextAdjacentEdge.md

@@ -9,7 +9,7 @@ Get the next adjacent edge to the edge given.
 
 
 ```js
-getNextAdjacentEdge(tag: TagIdentifier): Uuid
+getNextAdjacentEdge(edge: TagIdentifier): Uuid
 ```
 
 
@@ -17,7 +17,7 @@ getNextAdjacentEdge(tag: TagIdentifier): Uuid
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| [`tag`](/docs/kcl/types/tag) | [`TagIdentifier`](/docs/kcl/types#tag-identifier) |  | Yes |
+| `edge` | [`TagIdentifier`](/docs/kcl/types#tag-identifier) | The tag of the edge you want to find the next adjacent edge of. | Yes |
 
 ### Returns
 

docs/kcl/getOppositeEdge.md

@@ -9,7 +9,7 @@ Get the opposite edge to the edge given.
 
 
 ```js
-getOppositeEdge(tag: TagIdentifier): Uuid
+getOppositeEdge(edge: TagIdentifier): Uuid
 ```
 
 
@@ -17,7 +17,7 @@ getOppositeEdge(tag: TagIdentifier): Uuid
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| [`tag`](/docs/kcl/types/tag) | [`TagIdentifier`](/docs/kcl/types#tag-identifier) |  | Yes |
+| `edge` | [`TagIdentifier`](/docs/kcl/types#tag-identifier) | The tag of the edge you want to find the opposite edge of. | Yes |
 
 ### Returns
 

docs/kcl/getPreviousAdjacentEdge.md

@@ -9,7 +9,7 @@ Get the previous adjacent edge to the edge given.
 
 
 ```js
-getPreviousAdjacentEdge(tag: TagIdentifier): Uuid
+getPreviousAdjacentEdge(edge: TagIdentifier): Uuid
 ```
 
 
@@ -17,7 +17,7 @@ getPreviousAdjacentEdge(tag: TagIdentifier): Uuid
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| [`tag`](/docs/kcl/types/tag) | [`TagIdentifier`](/docs/kcl/types#tag-identifier) |  | Yes |
+| `edge` | [`TagIdentifier`](/docs/kcl/types#tag-identifier) | The tag of the edge you want to find the previous adjacent edge of. | Yes |
 
 ### Returns
 

docs/kcl/index.md

@@ -32,8 +32,6 @@ layout: manual
   * [`Z`](kcl/consts/std-Z)
   * [`abs`](kcl/abs)
   * [`acos`](kcl/acos)
-  * [`angleToMatchLengthX`](kcl/angleToMatchLengthX)
-  * [`angleToMatchLengthY`](kcl/angleToMatchLengthY)
   * [`angledLine`](kcl/angledLine)
   * [`angledLineThatIntersects`](kcl/angledLineThatIntersects)
   * [`appearance`](kcl/appearance)
@@ -47,6 +45,7 @@ layout: manual
   * [`ceil`](kcl/ceil)
   * [`chamfer`](kcl/chamfer)
   * [`circleThreePoint`](kcl/circleThreePoint)
+  * [`clone`](kcl/clone)
   * [`close`](kcl/close)
   * [`extrude`](kcl/extrude)
   * [`fillet`](kcl/fillet)
@@ -74,7 +73,7 @@ layout: manual
   * [`map`](kcl/map)
   * [`max`](kcl/max)
   * [`min`](kcl/min)
-  * [`offsetPlane`](kcl/offsetPlane)
+  * [`offsetPlane`](kcl/std-offsetPlane)
   * [`patternCircular2d`](kcl/patternCircular2d)
   * [`patternCircular3d`](kcl/patternCircular3d)
   * [`patternLinear2d`](kcl/patternLinear2d)

docs/kcl/known-issues.md

@@ -22,6 +22,5 @@ once fixed in engine will just start working here with no language changes.
     chamfer cases work currently.
 
 - **Appearance**: Changing the appearance on a loft does not work. 
-    Changing the appearance on an imported model does not work.
 
 - **CSG Booleans**: Coplanar (bodies that share a plane) unions, subtractions, and intersections are not currently supported.

docs/kcl/legAngX.md

@@ -24,8 +24,8 @@ legAngX(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `hypotenuse` | [`number`](/docs/kcl/types/number) |  | Yes |
-| `leg` | [`number`](/docs/kcl/types/number) |  | Yes |
+| `hypotenuse` | [`number`](/docs/kcl/types/number) | The length of the triangle's hypotenuse | Yes |
+| `leg` | [`number`](/docs/kcl/types/number) | The length of one of the triangle's legs (i.e. non-hypotenuse side) | Yes |
 
 ### Returns
 
@@ -35,7 +35,7 @@ legAngX(
 ### Examples
 
 ```js
-legAngX(5, 3)
+legAngX(hypotenuse = 5, leg = 3)
 ```
 
 

docs/kcl/legAngY.md

@@ -24,8 +24,8 @@ legAngY(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `hypotenuse` | [`number`](/docs/kcl/types/number) |  | Yes |
-| `leg` | [`number`](/docs/kcl/types/number) |  | Yes |
+| `hypotenuse` | [`number`](/docs/kcl/types/number) | The length of the triangle's hypotenuse | Yes |
+| `leg` | [`number`](/docs/kcl/types/number) | The length of one of the triangle's legs (i.e. non-hypotenuse side) | Yes |
 
 ### Returns
 
@@ -35,7 +35,7 @@ legAngY(
 ### Examples
 
 ```js
-legAngY(5, 3)
+legAngY(hypotenuse = 5, leg = 3)
 ```
 
 

docs/kcl/legLen.md

@@ -24,8 +24,8 @@ legLen(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `hypotenuse` | [`number`](/docs/kcl/types/number) |  | Yes |
-| `leg` | [`number`](/docs/kcl/types/number) |  | Yes |
+| `hypotenuse` | [`number`](/docs/kcl/types/number) | The length of the triangle's hypotenuse | Yes |
+| `leg` | [`number`](/docs/kcl/types/number) | The length of one of the triangle's legs (i.e. non-hypotenuse side) | Yes |
 
 ### Returns
 
@@ -35,7 +35,7 @@ legLen(
 ### Examples
 
 ```js
-legLen(5, 3)
+legLen(hypotenuse = 5, leg = 3)
 ```
 
 

docs/kcl/modules.md

@@ -10,7 +10,7 @@ isolated from other files as a separate module.
 When you define a function, you can use `export` before it to make it available
 to other modules.
 
-```
+```kcl
 // util.kcl
 export fn increment(x) {
   return x + 1
@@ -31,11 +31,11 @@ Imported files _must_ be in the same project so that units are uniform across
 modules. This means that it must be in the same directory.
 
 Import statements must be at the top-level of a file. It is not allowed to have
-an `import` statement inside a function or in the body of an if-else.
+an `import` statement inside a function or in the body of an if‑else.
 
 Multiple functions can be exported in a file.
 
-```
+```kcl
 // util.kcl
 export fn increment(x) {
   return x + 1
@@ -58,6 +58,211 @@ Imported symbols can be renamed for convenience or to avoid name collisions.
 import increment as inc, decrement as dec from "util.kcl"
 ```
 
+---
+
+## Functions vs `clone`
+
+There are two common patterns for re‑using geometry:
+
+1. **Wrap the construction in a function** – flexible and fully parametric.
+2. **Duplicate an existing object with `clone`** – lightning‑fast, but an exact
+   duplicate.
+
+### Parametric function example
+
+```kcl
+fn cube(center) {
+  return startSketchOn(XY)
+    |> startProfileAt([center[0] - 10, center[1] - 10], %)
+    |> line(endAbsolute = [center[0] + 10, center[1] - 10])
+    |> line(endAbsolute = [center[0] + 10, center[1] + 10])
+    |> line(endAbsolute = [center[0] - 10, center[1] + 10])
+    |> close()
+    |> extrude(length = 10)
+}
+
+myCube = cube([0, 0])
+```
+
+*Pros*
+- Any argument can be a parameter – size, position, appearance, etc.
+- Works great inside loops, arrays, or optimisation sweeps.
+
+*Cons*
+- Every invocation rebuilds the entire feature tree.
+- **Slower** than a straight duplicate – each call is its own render job.
+
+### `clone` example
+
+```kcl
+sketch001 = startSketchOn(-XZ)
+  |> circle(center = [0, 0], radius = 10)
+  |> extrude(length = 5) 
+  |> appearance(color = "#ff0000", metalness = 90, roughness = 90)
+
+sketch002 = clone(sketch001)  // ✓ instant copy
+```
+
+*Pros*
+- Roughly an O(1) operation – we just duplicate the underlying engine handle.
+- Perfect when you need ten identical bolts or two copies of the same imported STEP file.
+
+*Cons*
+- **Not parametric** – the clone is exactly the same shape as the source.
+- If you need to tweak dimensions per‑instance, you’re back to a function.
+
+> **Rule of thumb** – Reach for `clone` when the geometry is already what you want. Reach for a function when you need customisation.
+
+---
+
+## Module‑level parallelism
+
+Under the hood, the Design Studio runs **every module in parallel** where it can. This means:
+
+- The top‑level code of `foo.kcl`, `bar.kcl`, and `baz.kcl` all start executing immediately and concurrently.
+- Imports that read foreign files (STEP/OBJ/…) overlap their I/O and background render.
+- CPU‑bound calculations in separate modules get their own worker threads.
+
+### Why modules beat one‑big‑file
+
+If you shoe‑horn everything into `main.kcl`, each statement runs sequentially:
+
+```norun
+import "big.step" as gizmo  // blocks main while reading
+
+gizmo |> translate(x=50)    // blocks again while waiting for render
+```
+
+Split `gizmo` into its own file and the read/render can overlap whatever else `main.kcl` is doing.
+
+```norun
+// gizmo.kcl                   (worker A)
+import "big.step"
+
+// main.kcl                    (worker B)
+import "gizmo.kcl" as gizmo   // non‑blocking
+
+// ... other setup ...
+
+gizmo |> translate(x=50)      // only blocks here
+```
+
+### Gotcha: defining but **not** calling functions
+
+Defining a function inside a module is instantaneous – we just record the byte‑code. The heavy lifting happens when the function is **called**. So:
+
+```norun
+// util.kcl
+export fn makeBolt(size) { /* … expensive CAD … */ }
+```
+
+If `main.kcl` waits until the very end to call `makeBolt`, *none* of that work was parallelised – you’ve pushed the cost back onto the serial tail of your script.
+
+**Better:** call it early or move the invocation into another module.
+
+```norun
+// bolt_instance.kcl
+import makeBolt from "util.kcl"
+bolt = makeBolt(5)  // executed in parallel
+bolt
+```
+
+Now `main.kcl` can `import "bolt_instance.kcl" as bolt` and get the result that was rendered while it was busy doing other things.
+
+---
+
+## Whole module import
+
+You can also import the whole module. This is useful if you want to use the
+result of a module as a variable, like a part.
+
+```norun
+import "tests/inputs/cube.kcl" as cube
+cube
+  |> translate(x=10)
+```
+
+This imports the whole module and makes it available as `cube`. You can then
+use it like any other object. The `cube` variable is now a reference to the
+result of the module. This means that if you change the module, the `cube`
+variable will change as well.
+
+In `cube.kcl`, you cannot have multiple objects. It has to be a single part. If
+you have multiple objects, you will get an error. This is because the module is
+expected to return a single object that can be used as a variable.
+
+You also cannot assign that object to a variable. This is because the module is
+expected to return a single object that can be used as a variable.
+
+So for example, this is not allowed:
+
+```norun
+... a bunch of code to create cube and cube2 ...
+
+myUnion = union([cube, cube2])
+```
+
+What you need to do instead is:
+
+```norun
+... a bunch of code to create cube and cube2 ...
+
+union([cube, cube2])
+```
+
+That way the last line will return the union of the two objects.
+
+Or what you could do instead is:
+
+```norun
+... a bunch of code to create cube and cube2 ...
+
+myUnion = union([cube, cube2])
+myUnion
+```
+
+This will return the union of the two objects, but it will not be assigned to a
+variable. This is because the module is expected to return a single object that
+can be used as a variable.
+
+---
+
+## Multiple instances of the same import
+
+Whether you are importing a file from another CAD system or a KCL file, that
+file represents object(s) in memory. If you import the same file multiple times,
+it will only be rendered once.
+
+If you want to have multiple instances of the same object, you can use the
+[`clone`](/docs/kcl/clone) function. This will render a new instance of the object in memory.
+
+```norun
+import cube from "tests/inputs/cube.kcl"
+
+cube  
+  |> translate(x=10)
+clone(cube)
+  |> translate(x=20)
+```
+
+In the sample above, the `cube` object is imported from a KCL file. The first
+instance is translated 10 units in the x direction. The second instance is
+cloned and translated 20 units in the x direction. The two instances are now
+separate objects in memory, and can be manipulated independently.
+
+Here is an example with a file from another CAD system:
+
+```kcl
+import "tests/inputs/cube.step" as cube
+
+cube
+  |> translate(x=10)
+clone(cube)
+  |> translate(x=20)
+```
+
+---
+
 ## Importing files from other CAD systems
 
 `import` can also be used to import files from other CAD systems. The format of the statement is the
@@ -69,25 +274,17 @@ import "tests/inputs/cube.obj"
 // Use `cube` just like a KCL object.
 ```
 
-```norun
-import "tests/inputs/cube-2.sldprt" as cube
+```kcl
+import "tests/inputs/cube.sldprt" as cube
 
 // Use `cube` just like a KCL object.
 ```
 
-You can make the file format explicit using a format attribute (useful if using a different
-extension), e.g.,
-
-```norun
-@(format = obj)
-import "tests/inputs/cube"
-```
-
 For formats lacking unit data (such as STL, OBJ, or PLY files), the default
 unit of measurement is millimeters. Alternatively you may specify the unit
-by using an attirbute. Likewise, you can also specify a coordinate system. E.g.,
+by using an attribute. Likewise, you can also specify a coordinate system. E.g.,
 
-```norun
+```kcl
 @(unitLength = ft, coords = opengl)
 import "tests/inputs/cube.obj"
 ```
@@ -110,97 +307,55 @@ Coordinate systems:
 - `opengl`, forward: +Z, up: +Y, handedness: right
 - `vulkan`, forward: +Z, up: -Y, handedness: left
 
-### Performance
+---
 
-Parallelized foreign-file imports now let you overlap file reads, initialization,
+## Performance deep‑dive for foreign‑file imports
+
+Parallelized foreign‑file imports now let you overlap file reads, initialization,
 and rendering. To maximize throughput, you need to understand the three distinct
 stages—reading, initializing (background render start), and invocation (blocking)
 —and structure your code to defer blocking operations until the end.
 
-#### Foreign Import Execution Stages
+### Foreign import execution stages
 
-1. **Import (Read) Stage**  
-   ```norun
+1. **Import (Read / Initialization) Stage**
+   ```kcl
    import "tests/inputs/cube.step" as cube
-   ```  
-   - Reads the file from disk and makes its API available.  
-   - **Does _not_** start Engine rendering or block your script.
+   ```
+   - Reads the file from disk and makes its API available.
+   - Starts engine rendering but **does not block** your script.
+   - This kick‑starts the render pipeline while you keep executing other code.
 
-2. **Initialization (Background Render) Stage**  
-   ```norun
+2. **Invocation (Blocking) Stage**
+   ```kcl
    import "tests/inputs/cube.step" as cube
 
-   myCube = cube    // <- This line starts background rendering
-   ```  
-   - Invoking the imported symbol (assignment or plain call) triggers Engine rendering _in the background_.  
-   - This kick‑starts the render pipeline but doesn’t block—you can continue other work while the Engine processes the model.
+   cube
+     |> translate(z=10) // ← blocks here only
+   ```
+   - Any method call (e.g., `translate`, `scale`, `rotate`) waits for the background render to finish before applying transformations.
 
-3. **Invocation (Blocking) Stage**  
-   ```norun
-   import "tests/inputs/cube.step" as cube
+### Best practices
 
-   myCube = cube
+#### 1. Defer blocking calls
 
-   myCube
-    |> translate(z=10) // <- This line blocks
-   ```  
-   - Any method call (e.g., `translate`, `scale`, `rotate`) waits for the background render to finish before applying transformations.  
-   - This is the only point where your script will block.
-
-> **Nuance:**  Foreign imports differ from pure KCL modules—calling the same import symbol multiple times (e.g., `screw` twice) starts background rendering twice.
-
-#### Best Practices
-
-##### 1. Defer Blocking Calls
-Initialize early but delay all transformations until after your heavy computation:
-```norun
-import "tests/inputs/cube.step" as cube     // 1) Read
-
-myCube = cube                               // 2) Background render starts
+```kcl
+import "tests/inputs/cube.step" as cube     // 1) Read / Background render starts
 
 
-// --- perform other operations and calculations or setup here ---
+// --- perform other operations and calculations here ---
 
 
-myCube
-  |> translate(z=10)                        // 3) Blocks only here
-```
-
-##### 2. Encapsulate Imports in Modules
-Keep `main.kcl` free of reads and initialization; wrap them:
-
-```norun
-// imports.kcl
-import "tests/inputs/cube.step" as cube    // Read only
-
-
-export myCube = cube                      // Kick off rendering
-```
-
-```norun
-// main.kcl
-import myCube from "imports.kcl"  // Import the initialized object 
-
-
-// ... computations ...
-
-
-myCube
-  |> translate(z=10)              // Blocking call at the end
-```
-
-##### 3. Avoid Immediate Method Calls
-
-```norun
-import "tests/inputs/cube.step" as cube
-
 cube
-  |> translate(z=10)              // Blocks immediately, negating parallelism
+  |> translate(z=10)                        // 2) Blocks only here
 ```
 
-Both calling methods right on `cube` immediately or leaving an implicit import without assignment introduce blocking.
+#### 2. Split heavy work into separate modules
 
-#### Future Improvements
+Place computationally expensive or IO‑heavy work into its own module so it can render in parallel while `main.kcl` continues.
+
+#### Future improvements
+
+Upcoming releases will auto‑analyse dependencies and only block when truly necessary. Until then, explicit deferral will give you the best performance.
 
-Upcoming releases will auto‑analyze dependencies and only block when truly necessary. Until then, explicit deferral and modular wrapping give you the best performance.
 

docs/kcl/types/ExtrudeSurface.md

@@ -51,6 +51,26 @@ An extruded arc.
 | `sourceRange` |`[integer, integer, integer]`| The source range. | No |
 
 
+----
+An extruded involute.
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `extrudeInvolute`|  | No |
+| `faceId` |[`string`](/docs/kcl/types/string)| The face id for the extrude surface. | No |
+| [`tag`](/docs/kcl/types/tag) |[`TagDeclarator`](/docs/kcl/types#tag-declaration)| The tag. | No |
+| `id` |[`string`](/docs/kcl/types/string)| The id of the geometry. | No |
+| `sourceRange` |`[integer, integer, integer]`| The source range. | No |
+
+
 ----
 Geometry metadata.
 

docs/kcl/types/GeometryWithImportedGeometry.md

@@ -0,0 +1,84 @@
+---
+title: "GeometryWithImportedGeometry"
+excerpt: "A geometry including an imported geometry."
+layout: manual
+---
+
+A geometry including an imported geometry.
+
+
+
+
+
+**This schema accepts exactly one of the following:**
+
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: [`Sketch`](/docs/kcl/types/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` |[`string`](/docs/kcl/types/string)| 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`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: [`Solid`](/docs/kcl/types/Solid)|  | No |
+| `id` |[`string`](/docs/kcl/types/string)| The id of the solid. | No |
+| `artifactId` |[`string`](/docs/kcl/types/string)| 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)| The units of the solid. | No |
+| `sectional` |`boolean`| Is this a sectional solid? | No |
+
+
+----
+Data for an imported geometry.
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `ImportedGeometry`|  | No |
+| `id` |[`string`](/docs/kcl/types/string)| The ID of the imported geometry. | No |
+| `value` |`[` [`string`](/docs/kcl/types/string) `]`| The original file paths. | No |
+
+
+----
+
+
+
+

docs/kcl/types/Path.md

@@ -241,6 +241,31 @@ A circular arc, not necessarily tangential to the current point.
 
 
 ----
+An involute of a circle of start_radius ending at end_radius
+
+**Type:** `object`
+
+
+
+
+
+## Properties
+
+| Property | Type | Description | Required |
+|----------|------|-------------|----------|
+| `type` |enum: `CircularInvolute`|  | No |
+| `start_radius` |[`number`](/docs/kcl/types/number)| The radius of the base circle of the involute | No |
+| `end_radius` |[`number`](/docs/kcl/types/number)| The radius that the involute ends at | No |
+| `angle` |[`number`](/docs/kcl/types/number)| Angle about which the whole involute is rotated | No |
+| `reverse` |`boolean`| If true, the path segment starts at the end radius and goes towards the start radius | 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 |
+
+
+----
 
 
 

docs/kcl/types/SketchSurface.md

@@ -30,7 +30,6 @@ A sketch type.
 | `origin` |[`Point3d`](/docs/kcl/types/Point3d)| Origin of the plane. | No |
 | `xAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the plane's X axis be? | No |
 | `yAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the plane's Y axis be? | No |
-| `zAxis` |[`Point3d`](/docs/kcl/types/Point3d)| The z-axis (normal). | No |
 
 
 ----
@@ -52,7 +51,6 @@ A face.
 | `value` |[`string`](/docs/kcl/types/string)| The tag of the face. | No |
 | `xAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the face's X axis be? | No |
 | `yAxis` |[`Point3d`](/docs/kcl/types/Point3d)| What should the face's Y axis be? | No |
-| `zAxis` |[`Point3d`](/docs/kcl/types/Point3d)| The z-axis (normal). | No |
 | `solid` |[`Solid`](/docs/kcl/types/Solid)| The solid the face is on. | No |
 | `units` |[`UnitLen`](/docs/kcl/types/UnitLen)| A unit of length. | No |
 

e2e/playwright/auth.spec.ts

@@ -13,12 +13,22 @@ test.describe('Authentication tests', () => {
       await page.setBodyDimensions({ width: 1000, height: 500 })
       await homePage.projectSection.waitFor()
 
+      // This is only needed as an override to test-utils' setup() for this test
+      await page.addInitScript(() => {
+        localStorage.setItem('TOKEN_PERSIST_KEY', '')
+      })
+
       await test.step('Click on sign out and expect sign in page', async () => {
         await toolbar.userSidebarButton.click()
         await toolbar.signOutButton.click()
         await expect(signInPage.signInButton).toBeVisible()
       })
 
+      await test.step("Refresh doesn't log the user back in", async () => {
+        await page.reload()
+        await expect(signInPage.signInButton).toBeVisible()
+      })
+
       await test.step('Click on sign in and cancel, click again and expect different code', async () => {
         await signInPage.signInButton.click()
         await expect(signInPage.userCode).toBeVisible()
@@ -30,6 +40,7 @@ test.describe('Authentication tests', () => {
         await expect(signInPage.userCode).toBeVisible()
         const secondUserCode = await signInPage.userCode.textContent()
         expect(secondUserCode).not.toEqual(firstUserCode)
+        await signInPage.cancelSignInButton.click()
       })
 
       await test.step('Press back button and remain on home page', async () => {
@@ -48,6 +59,12 @@ test.describe('Authentication tests', () => {
         // Longer timeout than usual here for the wait on home page
         await expect(homePage.projectSection).toBeVisible({ timeout: 10000 })
       })
+
+      await test.step('Click on sign out and expect sign in page', async () => {
+        await toolbar.userSidebarButton.click()
+        await toolbar.signOutButton.click()
+        await expect(signInPage.signInButton).toBeVisible()
+      })
     }
   )
 })

e2e/playwright/basic-sketch.spec.ts

@@ -155,7 +155,7 @@ async function doBasicSketch(
   |> xLine(length = -segLen(seg01))`)
 }
 
-test.describe('Basic sketch', { tag: ['@skipWin'] }, () => {
+test.describe('Basic sketch', () => {
   test('code pane open at start', async ({ page, homePage }) => {
     test.fixme(orRunWhenFullSuiteEnabled())
     await doBasicSketch(page, homePage, ['code'])

e2e/playwright/can-create-sketches-on-all-planes-and-their-back-sides.spec.ts

@@ -8,130 +8,126 @@ import type { ToolbarFixture } from '@e2e/playwright/fixtures/toolbarFixture'
 import { getUtils } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe(
-  'Can create sketches on all planes and their back sides',
-  { tag: ['@skipWin'] },
-  () => {
-    const sketchOnPlaneAndBackSideTest = async (
-      page: Page,
-      homePage: HomePageFixture,
-      scene: SceneFixture,
-      toolbar: ToolbarFixture,
-      plane: string,
-      clickCoords: { x: number; y: number }
-    ) => {
-      const u = await getUtils(page)
-      await page.setBodyDimensions({ width: 1200, height: 500 })
+test.describe('Can create sketches on all planes and their back sides', () => {
+  const sketchOnPlaneAndBackSideTest = async (
+    page: Page,
+    homePage: HomePageFixture,
+    scene: SceneFixture,
+    toolbar: ToolbarFixture,
+    plane: string,
+    clickCoords: { x: number; y: number }
+  ) => {
+    const u = await getUtils(page)
+    await page.setBodyDimensions({ width: 1200, height: 500 })
 
-      await homePage.goToModelingScene()
-      const XYPlanRed: [number, number, number] = [98, 50, 51]
-      await scene.expectPixelColor(XYPlanRed, { x: 700, y: 300 }, 15)
+    await homePage.goToModelingScene()
+    const XYPlanRed: [number, number, number] = [98, 50, 51]
+    await scene.expectPixelColor(XYPlanRed, { x: 700, y: 300 }, 15)
 
-      await u.openDebugPanel()
+    await u.openDebugPanel()
 
-      const coord =
-        plane === '-XY' || plane === '-YZ' || plane === 'XZ' ? -100 : 100
-      const camCommand: EngineCommand = {
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_look_at',
-          center: { x: 0, y: 0, z: 0 },
-          vantage: { x: coord, y: coord, z: coord },
-          up: { x: 0, y: 0, z: 1 },
-        },
-      }
-      const updateCamCommand: EngineCommand = {
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_get_settings',
-        },
-      }
-
-      const code = `@settings(defaultLengthUnit = in)sketch001 = startSketchOn(${plane})profile001 = startProfileAt([0.91, -1.22], sketch001)`
-
-      await u.openDebugPanel()
-
-      await u.clearCommandLogs()
-      await page.getByRole('button', { name: 'Start Sketch' }).click()
-
-      await u.sendCustomCmd(camCommand)
-      await page.waitForTimeout(100)
-      await u.sendCustomCmd(updateCamCommand)
-
-      await u.closeDebugPanel()
-
-      await page.mouse.click(clickCoords.x, clickCoords.y)
-      await page.waitForTimeout(600) // wait for animation
-
-      await toolbar.waitUntilSketchingReady()
-
-      await expect(
-        page.getByRole('button', { name: 'line Line', exact: true })
-      ).toBeVisible()
-
-      await u.closeDebugPanel()
-      await page.mouse.click(707, 393)
-
-      await expect(page.locator('.cm-content')).toHaveText(code)
-
-      await page
-        .getByRole('button', { name: 'line Line', exact: true })
-        .first()
-        .click()
-      await u.openAndClearDebugPanel()
-      await page.getByRole('button', { name: 'Exit Sketch' }).click()
-      await u.expectCmdLog('[data-message-type="execution-done"]')
-
-      await u.clearCommandLogs()
-      await u.removeCurrentCode()
+    const coord =
+      plane === '-XY' || plane === '-YZ' || plane === 'XZ' ? -100 : 100
+    const camCommand: EngineCommand = {
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'default_camera_look_at',
+        center: { x: 0, y: 0, z: 0 },
+        vantage: { x: coord, y: coord, z: coord },
+        up: { x: 0, y: 0, z: 1 },
+      },
+    }
+    const updateCamCommand: EngineCommand = {
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'default_camera_get_settings',
+      },
     }
 
-    const planeConfigs = [
-      {
-        plane: 'XY',
-        coords: { x: 600, y: 388 },
-        description: 'red plane',
-      },
-      {
-        plane: 'YZ',
-        coords: { x: 700, y: 250 },
-        description: 'green plane',
-      },
-      {
-        plane: 'XZ',
-        coords: { x: 684, y: 427 },
-        description: 'blue plane',
-      },
-      {
-        plane: '-XY',
-        coords: { x: 600, y: 118 },
-        description: 'back of red plane',
-      },
-      {
-        plane: '-YZ',
-        coords: { x: 700, y: 219 },
-        description: 'back of green plane',
-      },
-      {
-        plane: '-XZ',
-        coords: { x: 700, y: 80 },
-        description: 'back of blue plane',
-      },
-    ]
+    const code = `@settings(defaultLengthUnit = in)sketch001 = startSketchOn(${plane})profile001 = startProfileAt([0.91, -1.22], sketch001)`
 
-    for (const config of planeConfigs) {
-      test(config.plane, async ({ page, homePage, scene, toolbar }) => {
-        await sketchOnPlaneAndBackSideTest(
-          page,
-          homePage,
-          scene,
-          toolbar,
-          config.plane,
-          config.coords
-        )
-      })
-    }
+    await u.openDebugPanel()
+
+    await u.clearCommandLogs()
+    await page.getByRole('button', { name: 'Start Sketch' }).click()
+
+    await u.sendCustomCmd(camCommand)
+    await page.waitForTimeout(100)
+    await u.sendCustomCmd(updateCamCommand)
+
+    await u.closeDebugPanel()
+
+    await page.mouse.click(clickCoords.x, clickCoords.y)
+    await page.waitForTimeout(600) // wait for animation
+
+    await toolbar.waitUntilSketchingReady()
+
+    await expect(
+      page.getByRole('button', { name: 'line Line', exact: true })
+    ).toBeVisible()
+
+    await u.closeDebugPanel()
+    await page.mouse.click(707, 393)
+
+    await expect(page.locator('.cm-content')).toHaveText(code)
+
+    await page
+      .getByRole('button', { name: 'line Line', exact: true })
+      .first()
+      .click()
+    await u.openAndClearDebugPanel()
+    await page.getByRole('button', { name: 'Exit Sketch' }).click()
+    await u.expectCmdLog('[data-message-type="execution-done"]')
+
+    await u.clearCommandLogs()
+    await u.removeCurrentCode()
   }
-)
+
+  const planeConfigs = [
+    {
+      plane: 'XY',
+      coords: { x: 600, y: 388 },
+      description: 'red plane',
+    },
+    {
+      plane: 'YZ',
+      coords: { x: 700, y: 250 },
+      description: 'green plane',
+    },
+    {
+      plane: 'XZ',
+      coords: { x: 684, y: 427 },
+      description: 'blue plane',
+    },
+    {
+      plane: '-XY',
+      coords: { x: 600, y: 118 },
+      description: 'back of red plane',
+    },
+    {
+      plane: '-YZ',
+      coords: { x: 700, y: 219 },
+      description: 'back of green plane',
+    },
+    {
+      plane: '-XZ',
+      coords: { x: 700, y: 80 },
+      description: 'back of blue plane',
+    },
+  ]
+
+  for (const config of planeConfigs) {
+    test(config.plane, async ({ page, homePage, scene, toolbar }) => {
+      await sketchOnPlaneAndBackSideTest(
+        page,
+        homePage,
+        scene,
+        toolbar,
+        config.plane,
+        config.coords
+      )
+    })
+  }
+})

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

@@ -10,7 +10,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Code pane and errors', { tag: ['@skipWin'] }, () => {
+test.describe('Code pane and errors', () => {
   test('Typing KCL errors induces a badge on the code pane button', async ({
     page,
     homePage,

e2e/playwright/command-bar-tests.spec.ts

@@ -9,7 +9,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Command bar tests', { tag: ['@skipWin'] }, () => {
+test.describe('Command bar tests', () => {
   test('Extrude from command bar selects extrude line after', async ({
     page,
     homePage,
@@ -179,57 +179,57 @@ test.describe('Command bar tests', { tag: ['@skipWin'] }, () => {
     await expect(commandLevelArgButton).toHaveText('level: project')
   })
 
-  test(
-    'Command bar keybinding works from code editor and can change a setting',
-    { tag: ['@skipWin'] },
-    async ({ page, homePage }) => {
-      await page.setBodyDimensions({ width: 1200, height: 500 })
-      await homePage.goToModelingScene()
+  test('Command bar keybinding works from code editor and can change a setting', async ({
+    page,
+    homePage,
+  }) => {
+    await page.setBodyDimensions({ width: 1200, height: 500 })
+    await homePage.goToModelingScene()
 
-      // FIXME: No KCL code, unable to wait for engine execution
-      await page.waitForTimeout(10000)
+    // FIXME: No KCL code, unable to wait for engine execution
+    await page.waitForTimeout(10000)
 
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).not.toBeDisabled()
+    await expect(
+      page.getByRole('button', { name: 'Start Sketch' })
+    ).not.toBeDisabled()
 
-      // Put the cursor in the code editor
-      await page.locator('.cm-content').click()
+    // Put the cursor in the code editor
+    await page.locator('.cm-content').click()
 
-      // Now try the same, but with the keyboard shortcut, check focus
-      await page.keyboard.press('ControlOrMeta+K')
+    // Now try the same, but with the keyboard shortcut, check focus
+    await page.keyboard.press('ControlOrMeta+K')
 
-      let cmdSearchBar = page.getByPlaceholder('Search commands')
-      await expect(cmdSearchBar).toBeVisible()
-      await expect(cmdSearchBar).toBeFocused()
+    let cmdSearchBar = page.getByPlaceholder('Search commands')
+    await expect(cmdSearchBar).toBeVisible()
+    await expect(cmdSearchBar).toBeFocused()
 
-      // Try typing in the command bar
-      await cmdSearchBar.fill('theme')
-      const themeOption = page.getByRole('option', {
-        name: 'Settings · app · theme',
-      })
-      await expect(themeOption).toBeVisible()
-      await themeOption.click()
-      const themeInput = page.getByPlaceholder('dark')
-      await expect(themeInput).toBeVisible()
-      await expect(themeInput).toBeFocused()
-      // Select dark theme
-      await page.keyboard.press('ArrowDown')
-      await page.keyboard.press('ArrowDown')
-      await page.keyboard.press('ArrowDown')
-      await expect(
-        page.getByRole('option', { name: 'system' })
-      ).toHaveAttribute('data-headlessui-state', 'active')
-      await page.keyboard.press('Enter')
+    // Try typing in the command bar
+    await cmdSearchBar.fill('theme')
+    const themeOption = page.getByRole('option', {
+      name: 'Settings · app · theme',
+    })
+    await expect(themeOption).toBeVisible()
+    await themeOption.click()
+    const themeInput = page.getByPlaceholder('dark')
+    await expect(themeInput).toBeVisible()
+    await expect(themeInput).toBeFocused()
+    // Select dark theme
+    await page.keyboard.press('ArrowDown')
+    await page.keyboard.press('ArrowDown')
+    await page.keyboard.press('ArrowDown')
+    await expect(page.getByRole('option', { name: 'system' })).toHaveAttribute(
+      'data-headlessui-state',
+      'active'
+    )
+    await page.keyboard.press('Enter')
 
-      // Check the toast appeared
-      await expect(
-        page.getByText(`Set theme to "system" as a user default`)
-      ).toBeVisible()
-      // Check that the theme changed
-      await expect(page.locator('body')).not.toHaveClass(`body-bg dark`)
-    }
-  )
+    // Check the toast appeared
+    await expect(
+      page.getByText(`Set theme to "system" as a user default`)
+    ).toBeVisible()
+    // Check that the theme changed
+    await expect(page.locator('body')).not.toHaveClass(`body-bg dark`)
+  })
 
   test('Can extrude from the command bar', async ({
     page,

e2e/playwright/desktop-export.spec.ts

@@ -10,7 +10,7 @@ import { expect, test } from '@e2e/playwright/zoo-test'
 
 test(
   'export works on the first try',
-  { tag: ['@electron', '@skipLocalEngine'] },
+  { tag: ['@electron', '@macos', '@windows', '@skipLocalEngine'] },
   async ({ page, context, scene, tronApp, cmdBar }, testInfo) => {
     if (!tronApp) {
       fail()

e2e/playwright/editor-tests.spec.ts

@@ -10,7 +10,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Editor tests', { tag: ['@skipWin'] }, () => {
+test.describe('Editor tests', () => {
   test('can comment out code with ctrl+/', async ({ page, homePage }) => {
     const u = await getUtils(page)
     await page.setBodyDimensions({ width: 1000, height: 500 })
@@ -989,162 +989,162 @@ sketch001 = startSketchOn(XZ)
   |> close()`)
   })
 
-  test(
-    'Can undo a sketch modification with ctrl+z',
-    { tag: ['@skipWin'] },
-    async ({ page, homePage, editor }) => {
-      const u = await getUtils(page)
-      await page.addInitScript(async () => {
-        localStorage.setItem(
-          'persistCode',
-          `@settings(defaultLengthUnit=in)
+  test('Can undo a sketch modification with ctrl+z', async ({
+    page,
+    homePage,
+    editor,
+  }) => {
+    const u = await getUtils(page)
+    await page.addInitScript(async () => {
+      localStorage.setItem(
+        'persistCode',
+        `@settings(defaultLengthUnit=in)
 sketch001 = startSketchOn(XZ)
   |> startProfileAt([4.61, -10.01], %)
   |> line(end = [12.73, -0.09])
   |> tangentialArc(endAbsolute = [24.95, -0.38])
   |> close()
   |> extrude(length = 5)`
-        )
-      })
+      )
+    })
 
-      await page.setBodyDimensions({ width: 1200, height: 500 })
+    await page.setBodyDimensions({ width: 1200, height: 500 })
 
-      await homePage.goToModelingScene()
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).not.toBeDisabled()
+    await homePage.goToModelingScene()
+    await expect(
+      page.getByRole('button', { name: 'Start Sketch' })
+    ).not.toBeDisabled()
 
-      await page.waitForTimeout(100)
-      await u.openAndClearDebugPanel()
-      await u.sendCustomCmd({
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_look_at',
-          vantage: { x: 0, y: -1250, z: 580 },
-          center: { x: 0, y: 0, z: 0 },
-          up: { x: 0, y: 0, z: 1 },
-        },
-      })
-      await page.waitForTimeout(100)
-      await u.sendCustomCmd({
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_get_settings',
-        },
-      })
-      await page.waitForTimeout(100)
+    await page.waitForTimeout(100)
+    await u.openAndClearDebugPanel()
+    await u.sendCustomCmd({
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'default_camera_look_at',
+        vantage: { x: 0, y: -1250, z: 580 },
+        center: { x: 0, y: 0, z: 0 },
+        up: { x: 0, y: 0, z: 1 },
+      },
+    })
+    await page.waitForTimeout(100)
+    await u.sendCustomCmd({
+      type: 'modeling_cmd_req',
+      cmd_id: uuidv4(),
+      cmd: {
+        type: 'default_camera_get_settings',
+      },
+    })
+    await page.waitForTimeout(100)
 
-      const startPX = [1200 / 2, 500 / 2]
+    const startPX = [1200 / 2, 500 / 2]
 
-      const dragPX = 40
+    const dragPX = 40
 
-      await page.getByText('startProfileAt([4.61, -10.01], %)').click()
-      await expect(
-        page.getByRole('button', { name: 'Edit Sketch' })
-      ).toBeVisible()
-      await page.getByRole('button', { name: 'Edit Sketch' }).click()
-      await page.waitForTimeout(400)
-      let prevContent = await page.locator('.cm-content').innerText()
+    await page.getByText('startProfileAt([4.61, -10.01], %)').click()
+    await expect(
+      page.getByRole('button', { name: 'Edit Sketch' })
+    ).toBeVisible()
+    await page.getByRole('button', { name: 'Edit Sketch' }).click()
+    await page.waitForTimeout(400)
+    let prevContent = await page.locator('.cm-content').innerText()
 
-      await expect(page.getByTestId('segment-overlay')).toHaveCount(2)
+    await expect(page.getByTestId('segment-overlay')).toHaveCount(2)
 
-      // drag startProfileAt handle
-      await page.dragAndDrop('#stream', '#stream', {
-        sourcePosition: { x: startPX[0] + 68, y: startPX[1] + 147 },
-        targetPosition: { x: startPX[0] + dragPX, y: startPX[1] + dragPX },
-      })
-      await page.waitForTimeout(100)
-      await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
-      prevContent = await page.locator('.cm-content').innerText()
+    // drag startProfileAt handle
+    await page.dragAndDrop('#stream', '#stream', {
+      sourcePosition: { x: startPX[0] + 68, y: startPX[1] + 147 },
+      targetPosition: { x: startPX[0] + dragPX, y: startPX[1] + dragPX },
+    })
+    await page.waitForTimeout(100)
+    await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+    prevContent = await page.locator('.cm-content').innerText()
 
-      // drag line handle
-      // we wait so it saves the code
-      await page.waitForTimeout(800)
+    // drag line handle
+    // we wait so it saves the code
+    await page.waitForTimeout(800)
 
-      const lineEnd = await u.getBoundingBox('[data-overlay-index="0"]')
-      await page.waitForTimeout(100)
-      await page.dragAndDrop('#stream', '#stream', {
-        sourcePosition: { x: lineEnd.x - 5, y: lineEnd.y },
-        targetPosition: { x: lineEnd.x + dragPX, y: lineEnd.y + dragPX },
-      })
-      await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
-      prevContent = await page.locator('.cm-content').innerText()
+    const lineEnd = await u.getBoundingBox('[data-overlay-index="0"]')
+    await page.waitForTimeout(100)
+    await page.dragAndDrop('#stream', '#stream', {
+      sourcePosition: { x: lineEnd.x - 5, y: lineEnd.y },
+      targetPosition: { x: lineEnd.x + dragPX, y: lineEnd.y + dragPX },
+    })
+    await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+    prevContent = await page.locator('.cm-content').innerText()
 
-      // we wait so it saves the code
-      await page.waitForTimeout(800)
+    // we wait so it saves the code
+    await page.waitForTimeout(800)
 
-      // drag tangentialArc handle
-      const tangentEnd = await u.getBoundingBox('[data-overlay-index="1"]')
-      await page.dragAndDrop('#stream', '#stream', {
-        sourcePosition: { x: tangentEnd.x + 10, y: tangentEnd.y - 5 },
-        targetPosition: {
-          x: tangentEnd.x + dragPX,
-          y: tangentEnd.y + dragPX,
-        },
-      })
-      await page.waitForTimeout(100)
-      await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
+    // drag tangentialArc handle
+    const tangentEnd = await u.getBoundingBox('[data-overlay-index="1"]')
+    await page.dragAndDrop('#stream', '#stream', {
+      sourcePosition: { x: tangentEnd.x + 10, y: tangentEnd.y - 5 },
+      targetPosition: {
+        x: tangentEnd.x + dragPX,
+        y: tangentEnd.y + dragPX,
+      },
+    })
+    await page.waitForTimeout(100)
+    await expect(page.locator('.cm-content')).not.toHaveText(prevContent)
 
-      // expect the code to have changed
-      await editor.expectEditor.toContain(
-        `sketch001 = startSketchOn(XZ)
+    // expect the code to have changed
+    await editor.expectEditor.toContain(
+      `sketch001 = startSketchOn(XZ)
     |> startProfileAt([2.71, -2.71], %)
     |> line(end = [15.4, -2.78])
     |> tangentialArc(endAbsolute = [27.6, -3.05])
     |> close()
     |> extrude(length = 5)`,
-        { shouldNormalise: true }
-      )
+      { shouldNormalise: true }
+    )
 
-      // Hit undo
-      await page.keyboard.down('Control')
-      await page.keyboard.press('KeyZ')
-      await page.keyboard.up('Control')
+    // Hit undo
+    await page.keyboard.down('Control')
+    await page.keyboard.press('KeyZ')
+    await page.keyboard.up('Control')
 
-      await editor.expectEditor.toContain(
-        `sketch001 = startSketchOn(XZ)
+    await editor.expectEditor.toContain(
+      `sketch001 = startSketchOn(XZ)
     |> startProfileAt([2.71, -2.71], %)
     |> line(end = [15.4, -2.78])
     |> tangentialArc(endAbsolute = [24.95, -0.38])
     |> close()
     |> extrude(length = 5)`,
-        { shouldNormalise: true }
-      )
+      { shouldNormalise: true }
+    )
 
-      // Hit undo again.
-      await page.keyboard.down('Control')
-      await page.keyboard.press('KeyZ')
-      await page.keyboard.up('Control')
+    // Hit undo again.
+    await page.keyboard.down('Control')
+    await page.keyboard.press('KeyZ')
+    await page.keyboard.up('Control')
 
-      await editor.expectEditor.toContain(
-        `sketch001 = startSketchOn(XZ)
+    await editor.expectEditor.toContain(
+      `sketch001 = startSketchOn(XZ)
     |> startProfileAt([2.71, -2.71], %)
     |> line(end = [12.73, -0.09])
     |> tangentialArc(endAbsolute = [24.95, -0.38])
     |> close()
     |> extrude(length = 5)`,
-        { shouldNormalise: true }
-      )
+      { shouldNormalise: true }
+    )
 
-      // Hit undo again.
-      await page.keyboard.down('Control')
-      await page.keyboard.press('KeyZ')
-      await page.keyboard.up('Control')
+    // Hit undo again.
+    await page.keyboard.down('Control')
+    await page.keyboard.press('KeyZ')
+    await page.keyboard.up('Control')
 
-      await page.waitForTimeout(100)
-      await editor.expectEditor.toContain(
-        `sketch001 = startSketchOn(XZ)
+    await page.waitForTimeout(100)
+    await editor.expectEditor.toContain(
+      `sketch001 = startSketchOn(XZ)
     |> startProfileAt([4.61, -10.01], %)
     |> line(end = [12.73, -0.09])
     |> tangentialArc(endAbsolute = [24.95, -0.38])
     |> close()
     |> extrude(length = 5)`,
-        { shouldNormalise: true }
-      )
-    }
-  )
+      { shouldNormalise: true }
+    )
+  })
 
   test(
     `Can import a local OBJ file`,

e2e/playwright/file-tree.spec.ts

@@ -29,7 +29,7 @@ test.describe('integrations tests', () => {
         )
       })
 
-      const [clickObj] = await scene.makeMouseHelpers(726, 272)
+      const [clickObj] = scene.makeMouseHelpers(726, 272)
 
       await test.step('setup test', async () => {
         await homePage.expectState({
@@ -73,7 +73,7 @@ test.describe('integrations tests', () => {
       })
       await test.step('setup for next assertion', async () => {
         await toolbar.openFile('main.kcl')
-        await page.waitForTimeout(1000)
+        await page.waitForTimeout(2000)
         await clickObj()
         await page.waitForTimeout(1000)
         await scene.moveNoWhere()

e2e/playwright/fixtures/toolbarFixture.ts

@@ -174,6 +174,13 @@ export class ToolbarFixture {
   openFile = async (fileName: string) => {
     await this.filePane.getByText(fileName).click()
   }
+  selectTangentialArc = async () => {
+    await this.page.getByRole('button', { name: 'caret down arcs:' }).click()
+    await expect(
+      this.page.getByTestId('dropdown-three-point-arc')
+    ).toBeVisible()
+    await this.page.getByTestId('dropdown-tangential-arc').click()
+  }
   selectCenterRectangle = async () => {
     await this.page
       .getByRole('button', { name: 'caret down rectangles:' })

e2e/playwright/lib/api-reporter.ts

@@ -41,7 +41,7 @@ class MyAPIReporter implements Reporter {
       annotations: test.annotations.map((a) => a.type), // e.g. 'fail' or 'fixme'
       id: test.id, // computed file/test/project ID used for reruns
       retry: result.retry,
-      tags: test.tags, // e.g. '@snapshot' or '@skipWin'
+      tags: test.tags, // e.g. '@snapshot' or '@skipLocalEngine'
       // Extra environment variables
       CI_COMMIT_SHA: process.env.CI_COMMIT_SHA || null,
       CI_PR_NUMBER: process.env.CI_PR_NUMBER || null,

e2e/playwright/point-click-assemblies.spec.ts

@@ -6,6 +6,7 @@ import type { ToolbarFixture } from '@e2e/playwright/fixtures/toolbarFixture'
 import {
   executorInputPath,
   getUtils,
+  kclSamplesPath,
   testsInputPath,
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
@@ -472,4 +473,94 @@ test.describe('Point-and-click assemblies tests', () => {
       })
     }
   )
+
+  test(
+    'Assembly gets reexecuted when imported models are updated externally',
+    { tag: ['@electron'] },
+    async ({ context, page, homePage, scene, toolbar, cmdBar, tronApp }) => {
+      if (!tronApp) {
+        fail()
+      }
+
+      const midPoint = { x: 500, y: 250 }
+      const washerPoint = { x: 645, y: 250 }
+      const partColor: [number, number, number] = [120, 120, 120]
+      const redPartColor: [number, number, number] = [200, 0, 0]
+      const bgColor: [number, number, number] = [30, 30, 30]
+      const tolerance = 50
+      const projectName = 'assembly'
+
+      await test.step('Setup parts and expect imported model', async () => {
+        await context.folderSetupFn(async (dir) => {
+          const projectDir = path.join(dir, projectName)
+          await fsp.mkdir(projectDir, { recursive: true })
+          await Promise.all([
+            fsp.copyFile(
+              executorInputPath('cube.kcl'),
+              path.join(projectDir, 'cube.kcl')
+            ),
+            fsp.copyFile(
+              kclSamplesPath(
+                path.join(
+                  'pipe-flange-assembly',
+                  'mcmaster-parts',
+                  '98017a257-washer.step'
+                )
+              ),
+              path.join(projectDir, 'foreign.step')
+            ),
+            fsp.writeFile(
+              path.join(projectDir, 'main.kcl'),
+              `
+import "cube.kcl" as cube
+import "foreign.step" as foreign
+cube
+foreign
+  |> translate(x = 40, z = 10)`
+            ),
+          ])
+        })
+        await page.setBodyDimensions({ width: 1000, height: 500 })
+        await homePage.openProject(projectName)
+        await scene.settled(cmdBar)
+        await toolbar.closePane('code')
+        await scene.expectPixelColor(partColor, midPoint, tolerance)
+      })
+
+      await test.step('Change imported kcl file and expect change', async () => {
+        await context.folderSetupFn(async (dir) => {
+          // Append appearance to the cube.kcl file
+          await fsp.appendFile(
+            path.join(dir, projectName, 'cube.kcl'),
+            `\n  |> appearance(color = "#ff0000")`
+          )
+        })
+        await scene.settled(cmdBar)
+        await toolbar.closePane('code')
+        await scene.expectPixelColor(redPartColor, midPoint, tolerance)
+        await scene.expectPixelColor(partColor, washerPoint, tolerance)
+      })
+
+      await test.step('Change imported step file and expect change', async () => {
+        await context.folderSetupFn(async (dir) => {
+          // Replace the washer with a pipe
+          await fsp.copyFile(
+            kclSamplesPath(
+              path.join(
+                'pipe-flange-assembly',
+                'mcmaster-parts',
+                '1120t74-pipe.step'
+              )
+            ),
+            path.join(dir, projectName, 'foreign.step')
+          )
+        })
+        await scene.settled(cmdBar)
+        await toolbar.closePane('code')
+        // Expect pipe to take over the red cube but leave some space where the washer was
+        await scene.expectPixelColor(partColor, midPoint, tolerance)
+        await scene.expectPixelColor(bgColor, washerPoint, tolerance)
+      })
+    }
+  )
 })

e2e/playwright/projects.spec.ts

@@ -18,7 +18,7 @@ import { expect, test } from '@e2e/playwright/zoo-test'
 
 test(
   'projects reload if a new one is created, deleted, or renamed externally',
-  { tag: '@electron' },
+  { tag: ['@electron', '@macos', '@windows'] },
   async ({ context, page }, testInfo) => {
     let externalCreatedProjectName = 'external-created-project'
 
@@ -400,11 +400,6 @@ test(
     await expect(page.getByText('broken-code')).toBeVisible()
     await page.getByText('broken-code').click()
 
-    // Gotcha: You can not use scene.settled() since the KCL code is going to fail
-    await expect(
-      page.getByTestId('model-state-indicator-playing')
-    ).toBeAttached()
-
     // Gotcha: Scroll to the text content in code mirror because CodeMirror lazy loads DOM content
     await editor.scrollToText(
       "|> line(end = [0, wallMountL], tag = 'outerEdge')"
@@ -779,7 +774,9 @@ test.describe(`Project management commands`, () => {
       // Constants and locators
       const projectHomeLink = page.getByTestId('project-link')
       const commandButton = page.getByRole('button', { name: 'Commands' })
-      const commandOption = page.getByRole('option', { name: 'rename project' })
+      const commandOption = page.getByRole('option', {
+        name: 'rename project',
+      })
       const projectNameOption = page.getByRole('option', { name: projectName })
       const projectRenamedName = `untitled`
       // const projectMenuButton = page.getByTestId('project-sidebar-toggle')
@@ -839,7 +836,9 @@ test.describe(`Project management commands`, () => {
       // Constants and locators
       const projectHomeLink = page.getByTestId('project-link')
       const commandButton = page.getByRole('button', { name: 'Commands' })
-      const commandOption = page.getByRole('option', { name: 'delete project' })
+      const commandOption = page.getByRole('option', {
+        name: 'delete project',
+      })
       const projectNameOption = page.getByRole('option', { name: projectName })
       const commandWarning = page.getByText('Are you sure you want to delete?')
       const commandSubmitButton = page.getByRole('button', {
@@ -891,7 +890,9 @@ test.describe(`Project management commands`, () => {
       // Constants and locators
       const projectHomeLink = page.getByTestId('project-link')
       const commandButton = page.getByRole('button', { name: 'Commands' })
-      const commandOption = page.getByRole('option', { name: 'rename project' })
+      const commandOption = page.getByRole('option', {
+        name: 'rename project',
+      })
       const projectNameOption = page.getByRole('option', { name: projectName })
       const projectRenamedName = `untitled`
       const commandContinueButton = page.getByRole('button', {
@@ -947,7 +948,9 @@ test.describe(`Project management commands`, () => {
       // Constants and locators
       const projectHomeLink = page.getByTestId('project-link')
       const commandButton = page.getByRole('button', { name: 'Commands' })
-      const commandOption = page.getByRole('option', { name: 'delete project' })
+      const commandOption = page.getByRole('option', {
+        name: 'delete project',
+      })
       const projectNameOption = page.getByRole('option', { name: projectName })
       const commandWarning = page.getByText('Are you sure you want to delete?')
       const commandSubmitButton = page.getByRole('button', {
@@ -1812,8 +1815,8 @@ test(
         'basic_fillet_cube_next_adjacent.kcl',
         'basic_fillet_cube_previous_adjacent.kcl',
         'basic_fillet_cube_start.kcl',
-        'big_number_angle_to_match_length_x.kcl',
-        'big_number_angle_to_match_length_y.kcl',
+        'broken-code-test.kcl',
+        'circular_pattern3d_a_pattern.kcl',
         'close_arc.kcl',
         'computed_var.kcl',
         'cube-embedded.gltf',

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

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

e2e/playwright/regression-tests.spec.ts

@@ -14,7 +14,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Regression tests', { tag: ['@skipWin'] }, () => {
+test.describe('Regression tests', () => {
   // bugs we found that don't fit neatly into other categories
   test('bad model has inline error #3251', async ({
     context,
@@ -239,17 +239,18 @@ extrude001 = extrude(sketch001, length = 50)
     await expect(zooLogo).not.toHaveAttribute('href')
   })
 
-  test(
-    'Position _ Is Out Of Range... regression test',
-    { tag: ['@skipWin'] },
-    async ({ context, page, homePage }) => {
-      const u = await getUtils(page)
-      // const PUR = 400 / 37.5 //pixeltoUnitRatio
-      await page.setBodyDimensions({ width: 1200, height: 500 })
-      await context.addInitScript(async () => {
-        localStorage.setItem(
-          'persistCode',
-          `exampleSketch = startSketchOn("XZ")
+  test('Position _ Is Out Of Range... regression test', async ({
+    context,
+    page,
+    homePage,
+  }) => {
+    const u = await getUtils(page)
+    // const PUR = 400 / 37.5 //pixeltoUnitRatio
+    await page.setBodyDimensions({ width: 1200, height: 500 })
+    await context.addInitScript(async () => {
+      localStorage.setItem(
+        'persistCode',
+        `exampleSketch = startSketchOn("XZ")
       |> startProfileAt([0, 0], %)
       |> angledLine(angle = 50, length = 45 )
       |> yLine(endAbsolute = 0)
@@ -258,55 +259,55 @@ extrude001 = extrude(sketch001, length = 50)
 
     example = extrude(exampleSketch, length = 5)
     shell(exampleSketch, faces = ['end'], thickness = 0.25)`
-        )
+      )
+    })
+
+    await expect(async () => {
+      await homePage.goToModelingScene()
+      await u.waitForPageLoad()
+
+      // error in guter
+      await expect(page.locator('.cm-lint-marker-error')).toBeVisible({
+        timeout: 1_000,
       })
+      await page.waitForTimeout(200)
+      // expect it still to be there (sometimes it just clears for a bit?)
+      await expect(page.locator('.cm-lint-marker-error')).toBeVisible({
+        timeout: 1_000,
+      })
+    }).toPass({ timeout: 40_000, intervals: [1_000] })
 
-      await expect(async () => {
-        await homePage.goToModelingScene()
-        await u.waitForPageLoad()
+    // error text on hover
+    await page.hover('.cm-lint-marker-error')
+    await expect(page.getByText('Unexpected token: |').first()).toBeVisible()
 
-        // error in guter
-        await expect(page.locator('.cm-lint-marker-error')).toBeVisible({
-          timeout: 1_000,
-        })
-        await page.waitForTimeout(200)
-        // expect it still to be there (sometimes it just clears for a bit?)
-        await expect(page.locator('.cm-lint-marker-error')).toBeVisible({
-          timeout: 1_000,
-        })
-      }).toPass({ timeout: 40_000, intervals: [1_000] })
+    // Okay execution finished, let's start editing text below the error.
+    await u.codeLocator.click()
+    // Go to the end of the editor
+    // This bug happens when there is a diagnostic in the editor and you try to
+    // edit text below it.
+    // Or delete a huge chunk of text and then try to edit below it.
+    await page.keyboard.press('End')
+    await page.keyboard.down('Shift')
+    await page.keyboard.press('ArrowUp')
+    await page.keyboard.press('ArrowUp')
+    await page.keyboard.press('ArrowUp')
+    await page.keyboard.press('ArrowUp')
+    await page.keyboard.press('ArrowUp')
+    await page.keyboard.press('End')
+    await page.keyboard.up('Shift')
+    await page.keyboard.press('Backspace')
+    await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
 
-      // error text on hover
-      await page.hover('.cm-lint-marker-error')
-      await expect(page.getByText('Unexpected token: |').first()).toBeVisible()
+    await page.keyboard.press('Enter')
+    await page.keyboard.press('Enter')
+    await page.keyboard.type('thing: "blah"', { delay: 100 })
+    await page.keyboard.press('Enter')
+    await page.keyboard.press('ArrowLeft')
 
-      // Okay execution finished, let's start editing text below the error.
-      await u.codeLocator.click()
-      // Go to the end of the editor
-      // This bug happens when there is a diagnostic in the editor and you try to
-      // edit text below it.
-      // Or delete a huge chunk of text and then try to edit below it.
-      await page.keyboard.press('End')
-      await page.keyboard.down('Shift')
-      await page.keyboard.press('ArrowUp')
-      await page.keyboard.press('ArrowUp')
-      await page.keyboard.press('ArrowUp')
-      await page.keyboard.press('ArrowUp')
-      await page.keyboard.press('ArrowUp')
-      await page.keyboard.press('End')
-      await page.keyboard.up('Shift')
-      await page.keyboard.press('Backspace')
-      await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
-
-      await page.keyboard.press('Enter')
-      await page.keyboard.press('Enter')
-      await page.keyboard.type('thing: "blah"', { delay: 100 })
-      await page.keyboard.press('Enter')
-      await page.keyboard.press('ArrowLeft')
-
-      await expect(
-        page.locator('.cm-content')
-      ).toContainText(`exampleSketch = startSketchOn("XZ")
+    await expect(
+      page.locator('.cm-content')
+    ).toContainText(`exampleSketch = startSketchOn("XZ")
       |> startProfileAt([0, 0], %)
       |> angledLine(angle = 50, length = 45 )
       |> yLine(endAbsolute = 0)
@@ -314,9 +315,8 @@ extrude001 = extrude(sketch001, length = 50)
 
       thing: "blah"`)
 
-      await expect(page.locator('.cm-lint-marker-error')).toBeVisible()
-    }
-  )
+    await expect(page.locator('.cm-lint-marker-error')).toBeVisible()
+  })
 
   test(
     'window resize updates should reconfigure the stream',
@@ -486,82 +486,81 @@ extrude002 = extrude(profile002, length = 150)
     }
   )
   // We updated this test such that you can have multiple exports going at once.
-  test(
-    'ensure you CAN export while an export is already going',
-    { tag: ['@skipLinux', '@skipWin'] },
-    async ({ page, homePage }) => {
-      const u = await getUtils(page)
-      await test.step('Set up the code and durations', async () => {
-        await page.addInitScript(
-          async ({ code }) => {
-            localStorage.setItem('persistCode', code)
-            ;(window as any).playwrightSkipFilePicker = true
-          },
-          {
-            code: bracket,
-          }
-        )
+  test('ensure you CAN export while an export is already going', async ({
+    page,
+    homePage,
+  }) => {
+    const u = await getUtils(page)
+    await test.step('Set up the code and durations', async () => {
+      await page.addInitScript(
+        async ({ code }) => {
+          localStorage.setItem('persistCode', code)
+          ;(window as any).playwrightSkipFilePicker = true
+        },
+        {
+          code: bracket,
+        }
+      )
 
-        await page.setBodyDimensions({ width: 1000, height: 500 })
+      await page.setBodyDimensions({ width: 1000, height: 500 })
 
-        await homePage.goToModelingScene()
-        await u.waitForPageLoad()
+      await homePage.goToModelingScene()
+      await u.waitForPageLoad()
 
-        // wait for execution done
-        await u.openDebugPanel()
-        await u.expectCmdLog('[data-message-type="execution-done"]')
-        await u.closeDebugPanel()
+      // wait for execution done
+      await u.openDebugPanel()
+      await u.expectCmdLog('[data-message-type="execution-done"]')
+      await u.closeDebugPanel()
 
-        // expect zero errors in guter
-        await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
-      })
+      // expect zero errors in guter
+      await expect(page.locator('.cm-lint-marker-error')).not.toBeVisible()
+    })
 
-      const errorToastMessage = page.getByText(`Error while exporting`)
-      const exportingToastMessage = page.getByText(`Exporting...`)
-      const engineErrorToastMessage = page.getByText(`Nothing to export`)
-      const alreadyExportingToastMessage = page.getByText(`Already exporting`)
-      const successToastMessage = page.getByText(`Exported successfully`)
+    const errorToastMessage = page.getByText(`Error while exporting`)
+    const exportingToastMessage = page.getByText(`Exporting...`)
+    const engineErrorToastMessage = page.getByText(`Nothing to export`)
+    const alreadyExportingToastMessage = page.getByText(`Already exporting`)
+    const successToastMessage = page.getByText(`Exported successfully`)
 
-      await test.step('second export', async () => {
-        await clickExportButton(page)
+    await test.step('second export', async () => {
+      await clickExportButton(page)
 
-        await expect(exportingToastMessage).toBeVisible()
+      await expect(exportingToastMessage).toBeVisible()
 
-        await clickExportButton(page)
+      await clickExportButton(page)
 
-        await test.step('The first export still succeeds', async () => {
-          await Promise.all([
-            expect(exportingToastMessage).not.toBeVisible({ timeout: 15_000 }),
-            expect(errorToastMessage).not.toBeVisible(),
-            expect(engineErrorToastMessage).not.toBeVisible(),
-            expect(successToastMessage).toBeVisible({ timeout: 15_000 }),
-            expect(alreadyExportingToastMessage).not.toBeVisible({
-              timeout: 15_000,
-            }),
-          ])
-        })
-      })
-
-      await test.step('Successful, unblocked export', async () => {
-        // Try exporting again.
-        await clickExportButton(page)
-
-        // Find the toast.
-        // Look out for the toast message
-        await expect(exportingToastMessage).toBeVisible()
-
-        // Expect it to succeed.
+      await test.step('The first export still succeeds', async () => {
         await Promise.all([
-          expect(exportingToastMessage).not.toBeVisible(),
+          expect(exportingToastMessage).not.toBeVisible({ timeout: 15_000 }),
           expect(errorToastMessage).not.toBeVisible(),
           expect(engineErrorToastMessage).not.toBeVisible(),
-          expect(alreadyExportingToastMessage).not.toBeVisible(),
+          expect(successToastMessage).toBeVisible({ timeout: 15_000 }),
+          expect(alreadyExportingToastMessage).not.toBeVisible({
+            timeout: 15_000,
+          }),
         ])
-
-        await expect(successToastMessage).toHaveCount(2)
       })
-    }
-  )
+    })
+
+    await test.step('Successful, unblocked export', async () => {
+      // Try exporting again.
+      await clickExportButton(page)
+
+      // Find the toast.
+      // Look out for the toast message
+      await expect(exportingToastMessage).toBeVisible()
+
+      // Expect it to succeed.
+      await Promise.all([
+        expect(exportingToastMessage).not.toBeVisible(),
+        expect(errorToastMessage).not.toBeVisible(),
+        expect(engineErrorToastMessage).not.toBeVisible(),
+        expect(alreadyExportingToastMessage).not.toBeVisible(),
+      ])
+
+      await expect(successToastMessage).toHaveCount(2)
+    })
+  })
 
   test(
     `Network health indicator only appears in modeling view`,

e2e/playwright/snapshot-tests.spec.ts

@@ -47,7 +47,7 @@ test.setTimeout(60_000)
 // up with another PR if we want this back.
 test(
   'exports of each format should work',
-  { tag: ['@snapshot', '@skipWin', '@skipMacos'] },
+  { tag: ['@snapshot'] },
   async ({ page, context, scene, cmdBar, tronApp }) => {
     if (!tronApp) {
       fail()
@@ -464,9 +464,7 @@ test(
   |> xLine(length = 184.3)`
     await expect(page.locator('.cm-content')).toHaveText(code)
 
-    await page
-      .getByRole('button', { name: 'arc Tangential Arc', exact: true })
-      .click()
+    await toolbar.selectTangentialArc()
 
     // click on the end of the profile to continue it
     await page.waitForTimeout(500)
@@ -621,7 +619,7 @@ test.describe(
   'Client side scene scale should match engine scale',
   { tag: '@snapshot' },
   () => {
-    test('Inch scale', async ({ page, cmdBar, scene }) => {
+    test('Inch scale', async ({ page, cmdBar, scene, toolbar }) => {
       const u = await getUtils(page)
       await page.setViewportSize({ width: 1200, height: 500 })
       const PUR = 400 / 37.5 //pixeltoUnitRatio
@@ -655,9 +653,7 @@ test.describe(
   |> xLine(length = 184.3)`
       await expect(u.codeLocator).toHaveText(code)
 
-      await page
-        .getByRole('button', { name: 'arc Tangential Arc', exact: true })
-        .click()
+      await toolbar.selectTangentialArc()
       await page.waitForTimeout(100)
 
       // click to continue profile
@@ -671,9 +667,8 @@ test.describe(
       await expect(u.codeLocator).toHaveText(code)
 
       // click tangential arc tool again to unequip it
-      await page
-        .getByRole('button', { name: 'arc Tangential Arc', exact: true })
-        .click()
+      // it will be available directly in the toolbar since it was last equipped
+      await toolbar.tangentialArcBtn.click()
       await page.waitForTimeout(100)
 
       // screen shot should show the sketch
@@ -696,7 +691,13 @@ test.describe(
       })
     })
 
-    test('Millimeter scale', async ({ page, context, cmdBar, scene }) => {
+    test('Millimeter scale', async ({
+      page,
+      context,
+      cmdBar,
+      scene,
+      toolbar,
+    }) => {
       await context.addInitScript(
         async ({ settingsKey, settings }) => {
           localStorage.setItem(settingsKey, settings)
@@ -749,9 +750,7 @@ test.describe(
   |> xLine(length = 184.3)`
       await expect(u.codeLocator).toHaveText(code)
 
-      await page
-        .getByRole('button', { name: 'arc Tangential Arc', exact: true })
-        .click()
+      await toolbar.selectTangentialArc()
       await page.waitForTimeout(100)
 
       // click to continue profile
@@ -764,9 +763,7 @@ test.describe(
   |> tangentialArc(endAbsolute = [551.2, -62.01])`
       await expect(u.codeLocator).toHaveText(code)
 
-      await page
-        .getByRole('button', { name: 'arc Tangential Arc', exact: true })
-        .click()
+      await toolbar.tangentialArcBtn.click()
       await page.waitForTimeout(100)
 
       // screen shot should show the sketch

e2e/playwright/test-network-and-connection-issues.spec.ts

@@ -8,228 +8,235 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Test network and connection issues', () => {
-  test(
-    'simulate network down and network little widget',
-    { tag: '@skipLocalEngine' },
-    async ({ page, homePage }) => {
-      test.fixme(orRunWhenFullSuiteEnabled())
-      const u = await getUtils(page)
-      await page.setBodyDimensions({ width: 1200, height: 500 })
+test.describe(
+  'Test network and connection issues',
+  {
+    tag: ['@macos', '@windows'],
+  },
+  () => {
+    test(
+      'simulate network down and network little widget',
+      { tag: '@skipLocalEngine' },
+      async ({ page, homePage }) => {
+        test.fixme(orRunWhenFullSuiteEnabled())
+        const u = await getUtils(page)
+        await page.setBodyDimensions({ width: 1200, height: 500 })
 
-      await homePage.goToModelingScene()
+        await homePage.goToModelingScene()
 
-      const networkToggle = page.getByTestId('network-toggle')
+        const networkToggle = page.getByTestId('network-toggle')
 
-      // This is how we wait until the stream is online
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).not.toBeDisabled({ timeout: 15000 })
+        // This is how we wait until the stream is online
+        await expect(
+          page.getByRole('button', { name: 'Start Sketch' })
+        ).not.toBeDisabled({ timeout: 15000 })
 
-      const networkWidget = page.locator('[data-testid="network-toggle"]')
-      await expect(networkWidget).toBeVisible()
-      await networkWidget.hover()
+        const networkWidget = page.locator('[data-testid="network-toggle"]')
+        await expect(networkWidget).toBeVisible()
+        await networkWidget.hover()
 
-      const networkPopover = page.locator('[data-testid="network-popover"]')
-      await expect(networkPopover).not.toBeVisible()
+        const networkPopover = page.locator('[data-testid="network-popover"]')
+        await expect(networkPopover).not.toBeVisible()
 
-      // (First check) Expect the network to be up
-      await expect(networkToggle).toContainText('Connected')
+        // (First check) Expect the network to be up
+        await expect(networkToggle).toContainText('Connected')
 
-      // Click the network widget
-      await networkWidget.click()
+        // Click the network widget
+        await networkWidget.click()
 
-      // Check the modal opened.
-      await expect(networkPopover).toBeVisible()
+        // Check the modal opened.
+        await expect(networkPopover).toBeVisible()
 
-      // Click off the modal.
-      await page.mouse.click(100, 100)
-      await expect(networkPopover).not.toBeVisible()
+        // Click off the modal.
+        await page.mouse.click(100, 100)
+        await expect(networkPopover).not.toBeVisible()
 
-      // Turn off the network
-      await u.emulateNetworkConditions({
-        offline: true,
-        // values of 0 remove any active throttling. crbug.com/456324#c9
-        latency: 0,
-        downloadThroughput: -1,
-        uploadThroughput: -1,
-      })
+        // Turn off the network
+        await u.emulateNetworkConditions({
+          offline: true,
+          // values of 0 remove any active throttling. crbug.com/456324#c9
+          latency: 0,
+          downloadThroughput: -1,
+          uploadThroughput: -1,
+        })
 
-      // Expect the network to be down
-      await expect(networkToggle).toContainText('Problem')
+        // Expect the network to be down
+        await expect(networkToggle).toContainText('Problem')
 
-      // Click the network widget
-      await networkWidget.click()
+        // Click the network widget
+        await networkWidget.click()
 
-      // Check the modal opened.
-      await expect(networkPopover).toBeVisible()
+        // Check the modal opened.
+        await expect(networkPopover).toBeVisible()
 
-      // Click off the modal.
-      await page.mouse.click(0, 0)
-      await expect(networkPopover).not.toBeVisible()
+        // Click off the modal.
+        await page.mouse.click(0, 0)
+        await expect(networkPopover).not.toBeVisible()
 
-      // Turn back on the network
-      await u.emulateNetworkConditions({
-        offline: false,
-        // values of 0 remove any active throttling. crbug.com/456324#c9
-        latency: 0,
-        downloadThroughput: -1,
-        uploadThroughput: -1,
-      })
+        // Turn back on the network
+        await u.emulateNetworkConditions({
+          offline: false,
+          // values of 0 remove any active throttling. crbug.com/456324#c9
+          latency: 0,
+          downloadThroughput: -1,
+          uploadThroughput: -1,
+        })
 
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).not.toBeDisabled({ timeout: 15000 })
+        await expect(
+          page.getByRole('button', { name: 'Start Sketch' })
+        ).not.toBeDisabled({ timeout: 15000 })
 
-      // (Second check) expect the network to be up
-      await expect(networkToggle).toContainText('Connected')
-    }
-  )
+        // (Second check) expect the network to be up
+        await expect(networkToggle).toContainText('Connected')
+      }
+    )
 
-  test(
-    'Engine disconnect & reconnect in sketch mode',
-    { tag: '@skipLocalEngine' },
-    async ({ page, homePage, toolbar, scene, cmdBar }) => {
-      test.fixme(orRunWhenFullSuiteEnabled())
-      const networkToggle = page.getByTestId('network-toggle')
+    test(
+      'Engine disconnect & reconnect in sketch mode',
+      { tag: '@skipLocalEngine' },
+      async ({ page, homePage, toolbar, scene, cmdBar }) => {
+        test.fixme(orRunWhenFullSuiteEnabled())
+        const networkToggle = page.getByTestId('network-toggle')
 
-      const u = await getUtils(page)
-      await page.setBodyDimensions({ width: 1200, height: 500 })
-      const PUR = 400 / 37.5 //pixeltoUnitRatio
+        const u = await getUtils(page)
+        await page.setBodyDimensions({ width: 1200, height: 500 })
+        const PUR = 400 / 37.5 //pixeltoUnitRatio
 
-      await homePage.goToModelingScene()
-      await u.waitForPageLoad()
+        await homePage.goToModelingScene()
+        await u.waitForPageLoad()
 
-      await u.openDebugPanel()
-      // click on "Start Sketch" button
-      await u.clearCommandLogs()
-      await page.getByRole('button', { name: 'Start Sketch' }).click()
-      await page.waitForTimeout(100)
+        await u.openDebugPanel()
+        // click on "Start Sketch" button
+        await u.clearCommandLogs()
+        await page.getByRole('button', { name: 'Start Sketch' }).click()
+        await page.waitForTimeout(100)
 
-      // select a plane
-      await page.mouse.click(700, 200)
+        // select a plane
+        await page.mouse.click(700, 200)
 
-      await expect(page.locator('.cm-content')).toHaveText(
-        `sketch001 = startSketchOn(XZ)`
-      )
-      await u.closeDebugPanel()
+        await expect(page.locator('.cm-content')).toHaveText(
+          `sketch001 = startSketchOn(XZ)`
+        )
+        await u.closeDebugPanel()
 
-      await page.waitForTimeout(500) // TODO detect animation ending, or disable animation
+        await page.waitForTimeout(500) // TODO detect animation ending, or disable animation
 
-      const startXPx = 600
-      await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
-      await expect(page.locator('.cm-content')).toHaveText(
-        `sketch001 = startSketchOn(XZ)profile001 = startProfileAt(${commonPoints.startAt}, sketch001)`
-      )
-      await page.waitForTimeout(100)
+        const startXPx = 600
+        await page.mouse.click(startXPx + PUR * 10, 500 - PUR * 10)
+        await expect(page.locator('.cm-content')).toHaveText(
+          `sketch001 = startSketchOn(XZ)profile001 = startProfileAt(${commonPoints.startAt}, sketch001)`
+        )
+        await page.waitForTimeout(100)
 
-      await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 10)
-      await page.waitForTimeout(100)
+        await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 10)
+        await page.waitForTimeout(100)
 
-      await expect(
-        page.locator('.cm-content')
-      ).toHaveText(`sketch001 = startSketchOn(XZ)profile001 = startProfileAt(${commonPoints.startAt}, sketch001)
+        await expect(
+          page.locator('.cm-content')
+        ).toHaveText(`sketch001 = startSketchOn(XZ)profile001 = startProfileAt(${commonPoints.startAt}, sketch001)
       |> xLine(length = ${commonPoints.num1})`)
 
-      // Expect the network to be up
-      await expect(networkToggle).toContainText('Connected')
+        // Expect the network to be up
+        await expect(networkToggle).toContainText('Connected')
 
-      // simulate network down
-      await u.emulateNetworkConditions({
-        offline: true,
-        // values of 0 remove any active throttling. crbug.com/456324#c9
-        latency: 0,
-        downloadThroughput: -1,
-        uploadThroughput: -1,
-      })
+        // simulate network down
+        await u.emulateNetworkConditions({
+          offline: true,
+          // values of 0 remove any active throttling. crbug.com/456324#c9
+          latency: 0,
+          downloadThroughput: -1,
+          uploadThroughput: -1,
+        })
 
-      // Expect the network to be down
-      await expect(networkToggle).toContainText('Problem')
+        // Expect the network to be down
+        await expect(networkToggle).toContainText('Problem')
 
-      // Ensure we are not in sketch mode
-      await expect(
-        page.getByRole('button', { name: 'Exit Sketch' })
-      ).not.toBeVisible()
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).toBeVisible()
+        // Ensure we are not in sketch mode
+        await expect(
+          page.getByRole('button', { name: 'Exit Sketch' })
+        ).not.toBeVisible()
+        await expect(
+          page.getByRole('button', { name: 'Start Sketch' })
+        ).toBeVisible()
 
-      // simulate network up
-      await u.emulateNetworkConditions({
-        offline: false,
-        // values of 0 remove any active throttling. crbug.com/456324#c9
-        latency: 0,
-        downloadThroughput: -1,
-        uploadThroughput: -1,
-      })
+        // simulate network up
+        await u.emulateNetworkConditions({
+          offline: false,
+          // values of 0 remove any active throttling. crbug.com/456324#c9
+          latency: 0,
+          downloadThroughput: -1,
+          uploadThroughput: -1,
+        })
 
-      // Wait for the app to be ready for use
-      await expect(
-        page.getByRole('button', { name: 'Start Sketch' })
-      ).not.toBeDisabled({ timeout: 15000 })
+        // Wait for the app to be ready for use
+        await expect(
+          page.getByRole('button', { name: 'Start Sketch' })
+        ).not.toBeDisabled({ timeout: 15000 })
 
-      // Expect the network to be up
-      await expect(networkToggle).toContainText('Connected')
-      await scene.settled(cmdBar)
+        // Expect the network to be up
+        await expect(networkToggle).toContainText('Connected')
+        await scene.settled(cmdBar)
 
-      // Click off the code pane.
-      await page.mouse.click(100, 100)
+        // Click off the code pane.
+        await page.mouse.click(100, 100)
 
-      // select a line
-      await page
-        .getByText(`startProfileAt(${commonPoints.startAt}, sketch001)`)
-        .click()
+        // select a line
+        await page
+          .getByText(`startProfileAt(${commonPoints.startAt}, sketch001)`)
+          .click()
 
-      // enter sketch again
-      await toolbar.editSketch()
+        // enter sketch again
+        await toolbar.editSketch()
 
-      // Click the line tool
-      await page.getByRole('button', { name: 'line Line', exact: true }).click()
+        // Click the line tool
+        await page
+          .getByRole('button', { name: 'line Line', exact: true })
+          .click()
 
-      await page.waitForTimeout(150)
+        await page.waitForTimeout(150)
 
-      const camCommand: EngineCommand = {
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_look_at',
-          center: { x: 109, y: 0, z: -152 },
-          vantage: { x: 115, y: -505, z: -152 },
-          up: { x: 0, y: 0, z: 1 },
-        },
-      }
-      const updateCamCommand: EngineCommand = {
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_get_settings',
-        },
-      }
-      await toolbar.openPane('debug')
-      await u.sendCustomCmd(camCommand)
-      await page.waitForTimeout(100)
-      await u.sendCustomCmd(updateCamCommand)
-      await page.waitForTimeout(100)
+        const camCommand: EngineCommand = {
+          type: 'modeling_cmd_req',
+          cmd_id: uuidv4(),
+          cmd: {
+            type: 'default_camera_look_at',
+            center: { x: 109, y: 0, z: -152 },
+            vantage: { x: 115, y: -505, z: -152 },
+            up: { x: 0, y: 0, z: 1 },
+          },
+        }
+        const updateCamCommand: EngineCommand = {
+          type: 'modeling_cmd_req',
+          cmd_id: uuidv4(),
+          cmd: {
+            type: 'default_camera_get_settings',
+          },
+        }
+        await toolbar.openPane('debug')
+        await u.sendCustomCmd(camCommand)
+        await page.waitForTimeout(100)
+        await u.sendCustomCmd(updateCamCommand)
+        await page.waitForTimeout(100)
 
-      // click to continue profile
-      await page.mouse.click(1007, 400)
-      await page.waitForTimeout(100)
-      // Ensure we can continue sketching
-      await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 20)
-      await expect
-        .poll(u.normalisedEditorCode)
-        .toBe(`sketch001 = startSketchOn(XZ)
+        // click to continue profile
+        await page.mouse.click(1007, 400)
+        await page.waitForTimeout(100)
+        // Ensure we can continue sketching
+        await page.mouse.click(startXPx + PUR * 20, 500 - PUR * 20)
+        await expect
+          .poll(u.normalisedEditorCode)
+          .toBe(`sketch001 = startSketchOn(XZ)
 profile001 = startProfileAt([12.34, -12.34], sketch001)
   |> xLine(length = 12.34)
   |> line(end = [-12.34, 12.34])
 
 `)
-      await page.waitForTimeout(100)
-      await page.mouse.click(startXPx, 500 - PUR * 20)
+        await page.waitForTimeout(100)
+        await page.mouse.click(startXPx, 500 - PUR * 20)
 
-      await expect
-        .poll(u.normalisedEditorCode)
-        .toBe(`sketch001 = startSketchOn(XZ)
+        await expect
+          .poll(u.normalisedEditorCode)
+          .toBe(`sketch001 = startSketchOn(XZ)
 profile001 = startProfileAt([12.34, -12.34], sketch001)
   |> xLine(length = 12.34)
   |> line(end = [-12.34, 12.34])
@@ -237,21 +244,22 @@ profile001 = startProfileAt([12.34, -12.34], sketch001)
 
 `)
 
-      // Unequip line tool
-      await page.keyboard.press('Escape')
-      // Make sure we didn't pop out of sketch mode.
-      await expect(
-        page.getByRole('button', { name: 'Exit Sketch' })
-      ).toBeVisible()
-      await expect(
-        page.getByRole('button', { name: 'line Line', exact: true })
-      ).not.toHaveAttribute('aria-pressed', 'true')
+        // Unequip line tool
+        await page.keyboard.press('Escape')
+        // Make sure we didn't pop out of sketch mode.
+        await expect(
+          page.getByRole('button', { name: 'Exit Sketch' })
+        ).toBeVisible()
+        await expect(
+          page.getByRole('button', { name: 'line Line', exact: true })
+        ).not.toHaveAttribute('aria-pressed', 'true')
 
-      // Exit sketch
-      await page.keyboard.press('Escape')
-      await expect(
-        page.getByRole('button', { name: 'Exit Sketch' })
-      ).not.toBeVisible()
-    }
-  )
-})
+        // Exit sketch
+        await page.keyboard.press('Escape')
+        await expect(
+          page.getByRole('button', { name: 'Exit Sketch' })
+        ).not.toBeVisible()
+      }
+    )
+  }
+)

e2e/playwright/test-utils.ts

@@ -36,7 +36,6 @@ export const headerMasks = (page: Page) => [
 ]
 
 export const networkingMasks = (page: Page) => [
-  page.getByTestId('model-state-indicator'),
   page.getByTestId('network-toggle'),
 ]
 
@@ -85,12 +84,6 @@ async function waitForPageLoadWithRetry(page: Page) {
   await expect(async () => {
     await page.goto('/')
     const errorMessage = 'App failed to load - 🔃 Retrying ...'
-    await expect(
-      page.getByTestId('model-state-indicator-playing'),
-      errorMessage
-    ).toBeAttached({
-      timeout: 20_000,
-    })
 
     await expect(
       page.getByRole('button', { name: 'sketch Start Sketch' }),
@@ -103,11 +96,6 @@ async function waitForPageLoadWithRetry(page: Page) {
 
 // lee: This needs to be replaced by scene.settled() eventually.
 async function waitForPageLoad(page: Page) {
-  // wait for all spinners to be gone
-  await expect(page.getByTestId('model-state-indicator-playing')).toBeVisible({
-    timeout: 20_000,
-  })
-
   await expect(page.getByRole('button', { name: 'Start Sketch' })).toBeEnabled({
     timeout: 20_000,
   })
@@ -1036,6 +1024,10 @@ export function testsInputPath(fileName: string): string {
   return path.join('rust', 'kcl-lib', 'tests', 'inputs', fileName)
 }
 
+export function kclSamplesPath(fileName: string): string {
+  return path.join('public', 'kcl-samples', fileName)
+}
+
 export async function doAndWaitForImageDiff(
   page: Page,
   fn: () => Promise<unknown>,

e2e/playwright/testing-camera-movement.spec.ts

@@ -4,7 +4,7 @@ import { uuidv4 } from '@src/lib/utils'
 import { getUtils, orRunWhenFullSuiteEnabled } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Testing Camera Movement', { tag: ['@skipWin'] }, () => {
+test.describe('Testing Camera Movement', () => {
   test('Can move camera reliably', async ({
     page,
     context,

e2e/playwright/testing-constraints.spec.ts

@@ -10,7 +10,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Testing constraints', { tag: ['@skipWin'] }, () => {
+test.describe('Testing constraints', () => {
   test('Can constrain line length', async ({ page, homePage }) => {
     await page.addInitScript(async () => {
       localStorage.setItem(

e2e/playwright/testing-gizmo.spec.ts

@@ -4,7 +4,7 @@ import { TEST_CODE_GIZMO } from '@e2e/playwright/storageStates'
 import { getUtils } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Testing Gizmo', { tag: ['@skipWin'] }, () => {
+test.describe('Testing Gizmo', () => {
   const cases = [
     {
       testDescription: 'top view',

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

@@ -11,7 +11,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Testing segment overlays', { tag: ['@skipWin'] }, () => {
+test.describe('Testing segment overlays', () => {
   test('Hover over a segment should show its overlay, hovering over the input overlays should show its popover, clicking the input overlay should constrain/unconstrain it:\nfor the following segments', () => {
     // TODO: fix this test on mac after the electron migration
     test.fixme(orRunWhenFullSuiteEnabled())

e2e/playwright/testing-selections.spec.ts

@@ -9,7 +9,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Testing selections', { tag: ['@skipWin'] }, () => {
+test.describe('Testing selections', () => {
   test.setTimeout(90_000)
   test('Selections work on fresh and edited sketch', async ({
     page,
@@ -39,12 +39,12 @@ test.describe('Testing selections', { tag: ['@skipWin'] }, () => {
       })
     const emptySpaceHover = () =>
       test.step('Hover over empty space', async () => {
-        await page.mouse.move(700, 143, { steps: 5 })
+        await page.mouse.move(1000, 143, { steps: 5 })
         await expect(page.locator('.hover-highlight')).not.toBeVisible()
       })
     const emptySpaceClick = () =>
       test.step(`Click in empty space`, async () => {
-        await page.mouse.click(700, 143)
+        await page.mouse.click(1000, 143)
         await expect(page.locator('.cm-line').last()).toHaveClass(
           /cm-activeLine/
         )

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

@@ -9,7 +9,7 @@ import {
 } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
 
-test.describe('Text-to-CAD tests', { tag: ['@skipWin'] }, () => {
+test.describe('Text-to-CAD tests', () => {
   test('basic lego happy case', async ({ page, homePage }) => {
     const u = await getUtils(page)
 
@@ -436,93 +436,92 @@ test.describe('Text-to-CAD tests', { tag: ['@skipWin'] }, () => {
   })
 
   // This will be fine once greg makes prompt at top of file deterministic
-  test(
-    'can do many at once and get many prompts back, and interact with many',
-    { tag: ['@skipWin'] },
-    async ({ page, homePage }) => {
-      test.fixme(orRunWhenFullSuiteEnabled())
-      // Let this test run longer since we've seen it timeout.
-      test.setTimeout(180_000)
+  test('can do many at once and get many prompts back, and interact with many', async ({
+    page,
+    homePage,
+  }) => {
+    test.fixme(orRunWhenFullSuiteEnabled())
+    // Let this test run longer since we've seen it timeout.
+    test.setTimeout(180_000)
 
-      const u = await getUtils(page)
+    const u = await getUtils(page)
 
-      await page.setBodyDimensions({ width: 1000, height: 500 })
+    await page.setBodyDimensions({ width: 1000, height: 500 })
 
-      await homePage.goToModelingScene()
-      await u.waitForPageLoad()
+    await homePage.goToModelingScene()
+    await u.waitForPageLoad()
 
-      await sendPromptFromCommandBar(page, 'a 2x4 lego')
+    await sendPromptFromCommandBar(page, 'a 2x4 lego')
 
-      await sendPromptFromCommandBar(page, 'a 2x8 lego')
+    await sendPromptFromCommandBar(page, 'a 2x8 lego')
 
-      await sendPromptFromCommandBar(page, 'a 2x10 lego')
+    await sendPromptFromCommandBar(page, 'a 2x10 lego')
 
-      // Find the toast.
-      // Look out for the toast message
-      const submittingToastMessage = page.getByText(
-        `Submitting to Text-to-CAD API...`
-      )
-      await expect(submittingToastMessage.first()).toBeVisible()
+    // Find the toast.
+    // Look out for the toast message
+    const submittingToastMessage = page.getByText(
+      `Submitting to Text-to-CAD API...`
+    )
+    await expect(submittingToastMessage.first()).toBeVisible()
 
-      const generatingToastMessage = page.getByText(
-        `Generating parametric model...`
-      )
-      await expect(generatingToastMessage.first()).toBeVisible({
-        timeout: 10_000,
-      })
+    const generatingToastMessage = page.getByText(
+      `Generating parametric model...`
+    )
+    await expect(generatingToastMessage.first()).toBeVisible({
+      timeout: 10_000,
+    })
 
-      const successToastMessage = page.getByText(`Text-to-CAD successful`)
-      // We should have three success toasts.
-      await expect(successToastMessage).toHaveCount(3, { timeout: 25_000 })
+    const successToastMessage = page.getByText(`Text-to-CAD successful`)
+    // We should have three success toasts.
+    await expect(successToastMessage).toHaveCount(3, { timeout: 25_000 })
 
-      await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
-      await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
-      await expect(page.getByText(`a 2x10 lego`)).toBeVisible()
+    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
+    await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
+    await expect(page.getByText(`a 2x10 lego`)).toBeVisible()
 
-      // Ensure if you reject one, the others stay.
-      const rejectButton = page.getByRole('button', { name: 'Reject' })
-      await expect(rejectButton.first()).toBeVisible()
-      // Click the reject button on the first toast.
-      await rejectButton.first().click()
+    // Ensure if you reject one, the others stay.
+    const rejectButton = page.getByRole('button', { name: 'Reject' })
+    await expect(rejectButton.first()).toBeVisible()
+    // Click the reject button on the first toast.
+    await rejectButton.first().click()
 
-      // The first toast should disappear, but not the others.
-      await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
-      await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
-      await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
+    // The first toast should disappear, but not the others.
+    await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
+    await expect(page.getByText(`a 2x8 lego`)).toBeVisible()
+    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
 
-      // Ensure you can copy the code for one of the models remaining.
-      const copyToClipboardButton = page.getByRole('button', {
-        name: 'Accept',
-      })
-      await expect(copyToClipboardButton.first()).toBeVisible()
-      // Click the button.
-      await copyToClipboardButton.first().click()
+    // Ensure you can copy the code for one of the models remaining.
+    const copyToClipboardButton = page.getByRole('button', {
+      name: 'Accept',
+    })
+    await expect(copyToClipboardButton.first()).toBeVisible()
+    // Click the button.
+    await copyToClipboardButton.first().click()
 
-      // Do NOT do AI tests like this: "Expect the code to be pasted."
-      // Reason: AI tests are NONDETERMINISTIC. Thus we need to be as most
-      // general as we can for the assertion.
-      // We can use Kolmogorov complexity as a measurement of the
-      // "probably most minimal version of this program" to have a lower
-      // bound to work with. It is completely by feel because there are
-      // no proofs that any program is its smallest self.
-      const code2x8 = await page.locator('.cm-content').innerText()
-      await expect(code2x8.length).toBeGreaterThan(249)
+    // Do NOT do AI tests like this: "Expect the code to be pasted."
+    // Reason: AI tests are NONDETERMINISTIC. Thus we need to be as most
+    // general as we can for the assertion.
+    // We can use Kolmogorov complexity as a measurement of the
+    // "probably most minimal version of this program" to have a lower
+    // bound to work with. It is completely by feel because there are
+    // no proofs that any program is its smallest self.
+    const code2x8 = await page.locator('.cm-content').innerText()
+    await expect(code2x8.length).toBeGreaterThan(249)
 
-      // Ensure the final toast remains.
-      await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
-      await expect(page.getByText(`Prompt: "a 2x8 lego`)).not.toBeVisible()
-      await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
+    // Ensure the final toast remains.
+    await expect(page.getByText(`a 2x10 lego`)).not.toBeVisible()
+    await expect(page.getByText(`Prompt: "a 2x8 lego`)).not.toBeVisible()
+    await expect(page.getByText(`a 2x4 lego`)).toBeVisible()
 
-      // Ensure you can copy the code for the final model.
-      await expect(copyToClipboardButton).toBeVisible()
-      // Click the button.
-      await copyToClipboardButton.click()
+    // Ensure you can copy the code for the final model.
+    await expect(copyToClipboardButton).toBeVisible()
+    // Click the button.
+    await copyToClipboardButton.click()
 
-      // Expect the code to be pasted.
-      const code2x4 = await page.locator('.cm-content').innerText()
-      await expect(code2x4.length).toBeGreaterThan(249)
-    }
-  )
+    // Expect the code to be pasted.
+    const code2x4 = await page.locator('.cm-content').innerText()
+    await expect(code2x4.length).toBeGreaterThan(249)
+  })
 
   test('can do many at once with errors, clicking dismiss error does not dismiss all', async ({
     page,

e2e/playwright/various.spec.ts

@@ -178,6 +178,7 @@ test('Keyboard shortcuts can be viewed through the help menu', async ({
 test('First escape in tool pops you out of tool, second exits sketch mode', async ({
   page,
   homePage,
+  toolbar,
 }) => {
   // Wait for the app to be ready for use
   const u = await getUtils(page)
@@ -188,15 +189,6 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   await u.expectCmdLog('[data-message-type="execution-done"]')
   await u.closeDebugPanel()
 
-  const lineButton = page.getByRole('button', {
-    name: 'line Line',
-    exact: true,
-  })
-  const arcButton = page.getByRole('button', {
-    name: 'arc Tangential Arc',
-    exact: true,
-  })
-
   // Test these hotkeys perform actions when
   // focus is on the canvas
   await page.mouse.move(600, 250)
@@ -207,8 +199,8 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   await page.mouse.move(800, 300)
   await page.mouse.click(800, 300)
   await page.waitForTimeout(1000)
-  await expect(lineButton).toBeVisible()
-  await expect(lineButton).toHaveAttribute('aria-pressed', 'true')
+  await expect(toolbar.lineBtn).toBeVisible()
+  await expect(toolbar.lineBtn).toHaveAttribute('aria-pressed', 'true')
 
   // Draw a line
   await page.mouse.move(700, 200, { steps: 5 })
@@ -224,10 +216,9 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   await page.keyboard.press('Escape')
   // Make sure we didn't pop out of sketch mode.
   await expect(page.getByRole('button', { name: 'Exit Sketch' })).toBeVisible()
-  await expect(lineButton).not.toHaveAttribute('aria-pressed', 'true')
+  await expect(toolbar.lineBtn).not.toHaveAttribute('aria-pressed', 'true')
   // Equip arc tool
-  await page.keyboard.press('a')
-  await expect(arcButton).toHaveAttribute('aria-pressed', 'true')
+  await toolbar.selectTangentialArc()
 
   // click in the same position again to continue the profile
   await page.mouse.move(secondMousePosition.x, secondMousePosition.y, {
@@ -238,11 +229,14 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
   await page.mouse.move(1000, 100, { steps: 5 })
   await page.mouse.click(1000, 100)
   await page.keyboard.press('Escape')
-  await expect(arcButton).toHaveAttribute('aria-pressed', 'false')
+  await expect(toolbar.tangentialArcBtn).toHaveAttribute(
+    'aria-pressed',
+    'false'
+  )
   await expect
     .poll(async () => {
       await page.keyboard.press('l')
-      return lineButton.getAttribute('aria-pressed')
+      return toolbar.lineBtn.getAttribute('aria-pressed')
     })
     .toBe('true')
 
@@ -251,8 +245,11 @@ test('First escape in tool pops you out of tool, second exits sketch mode', asyn
 
   // Unequip line tool
   await page.keyboard.press('Escape')
-  await expect(lineButton).toHaveAttribute('aria-pressed', 'false')
-  await expect(arcButton).toHaveAttribute('aria-pressed', 'false')
+  await expect(toolbar.lineBtn).toHaveAttribute('aria-pressed', 'false')
+  await expect(toolbar.tangentialArcBtn).toHaveAttribute(
+    'aria-pressed',
+    'false'
+  )
   // Make sure we didn't pop out of sketch mode.
   await expect(page.getByRole('button', { name: 'Exit Sketch' })).toBeVisible()
   // Exit sketch

e2e/playwright/zoo-test.ts

@@ -30,21 +30,68 @@ declare module '@playwright/test' {
 // *for one worker*.
 const electronZooInstance = new ElectronZoo()
 
+// Track whether this is the first run for this worker process
+// Mac needs more time for the first window creation
+let isFirstRun = true
+
 // Our custom decorated Zoo test object. Makes it easier to add fixtures, and
 // switch between web and electron if needed.
 const playwrightTestFnWithFixtures_ = playwrightTestFn.extend<{
   tronApp?: ElectronZoo
 }>({
-  tronApp: async ({}, use, testInfo) => {
-    if (process.env.PLATFORM === 'web') {
-      await use(undefined)
-      return
-    }
+  tronApp: [
+    async ({}, use, testInfo) => {
+      if (process.env.PLATFORM === 'web') {
+        await use(undefined)
+        return
+      }
 
-    await electronZooInstance.createInstanceIfMissing(testInfo)
-    await use(electronZooInstance)
-    await electronZooInstance.makeAvailableAgain()
-  },
+      // Create a single timeout for the entire tronApp setup process
+      // This will ensure tests fail faster if there's an issue with setup
+      // instead of waiting for the full global timeout (120s)
+      // First runs need more time especially on Mac for window creation
+      const setupTimeout = isFirstRun ? 120_000 : 30_000
+      let timeoutId: NodeJS.Timeout | undefined
+
+      const setupPromise = new Promise<void>((resolve, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(
+            new Error(
+              `tronApp setup timed out after ${setupTimeout}ms${isFirstRun ? ' (first run)' : ' (subsequent run)'}`
+            )
+          )
+        }, setupTimeout)
+
+        // Execute the async setup in a separate function
+        const doSetup = async () => {
+          try {
+            await electronZooInstance.createInstanceIfMissing(testInfo)
+            resolve()
+          } catch (error) {
+            reject(error)
+          }
+        }
+
+        // Start the setup process
+        void doSetup()
+      })
+
+      try {
+        await setupPromise
+        if (timeoutId) clearTimeout(timeoutId)
+
+        // First run is complete at this point
+        isFirstRun = false
+
+        await use(electronZooInstance)
+        await electronZooInstance.makeAvailableAgain()
+      } catch (error) {
+        if (timeoutId) clearTimeout(timeoutId)
+        throw error
+      }
+    },
+    { timeout: 120_000 }, // Keep the global timeout as fallback
+  ],
 })
 
 const test = playwrightTestFnWithFixtures_.extend<Fixtures>(

interface.d.ts

@@ -20,6 +20,7 @@ export interface IElectronAPI {
   open: typeof dialog.showOpenDialog
   save: typeof dialog.showSaveDialog
   openExternal: typeof shell.openExternal
+  openInNewWindow: (name: string) => void
   takeElectronWindowScreenshot: ({
     width,
     height,

known-circular.txt

@@ -3,14 +3,13 @@
 > dpdm --no-warning --no-tree -T --skip-dynamic-imports=circular src/index.tsx
 
 • Circular Dependencies
-  01) src/lang/std/sketch.ts -> src/lang/modifyAst.ts -> src/lang/modifyAst/addEdgeTreatment.ts
-  02) src/lang/std/sketch.ts -> src/lang/modifyAst.ts
-  03) src/lang/std/sketch.ts -> src/lang/modifyAst.ts -> src/lang/std/sketchcombos.ts
-  04) src/lib/singletons.ts -> src/editor/manager.ts -> src/lib/selections.ts
-  05) src/lib/singletons.ts -> src/editor/manager.ts -> src/lib/selections.ts -> src/machines/appMachine.ts -> src/machines/engineStreamMachine.ts
-  06) src/lib/singletons.ts -> src/editor/manager.ts -> src/lib/selections.ts -> src/machines/appMachine.ts -> src/machines/settingsMachine.ts
-  07) src/machines/appMachine.ts -> src/machines/settingsMachine.ts -> src/machines/commandBarMachine.ts -> src/lib/commandBarConfigs/authCommandConfig.ts
-  08) src/lib/singletons.ts -> src/lang/codeManager.ts
-  09) src/lib/singletons.ts -> src/clientSideScene/sceneEntities.ts -> src/clientSideScene/segments.ts -> src/components/Toolbar/angleLengthInfo.ts
-  10) src/hooks/useModelingContext.ts -> src/components/ModelingMachineProvider.tsx -> src/components/Toolbar/Intersect.tsx -> src/components/SetHorVertDistanceModal.tsx -> src/lib/useCalculateKclExpression.ts
-  11) src/routes/Onboarding/index.tsx -> src/routes/Onboarding/Camera.tsx -> src/routes/Onboarding/utils.tsx
+  1) src/lang/std/sketch.ts -> src/lang/modifyAst.ts -> src/lang/modifyAst/addEdgeTreatment.ts
+  2) src/lang/std/sketch.ts -> src/lang/modifyAst.ts
+  3) src/lang/std/sketch.ts -> src/lang/modifyAst.ts -> src/lang/std/sketchcombos.ts
+  4) src/lib/singletons.ts -> src/editor/manager.ts -> src/lib/selections.ts
+  5) src/lib/singletons.ts -> src/editor/manager.ts -> src/lib/selections.ts
+  6) src/lib/singletons.ts -> src/lang/codeManager.ts
+  7) src/lib/singletons.ts -> src/clientSideScene/sceneEntities.ts -> src/clientSideScene/segments.ts -> src/components/Toolbar/angleLengthInfo.ts
+  8) src/lib/singletons.ts -> src/clientSideScene/sceneEntities.ts -> src/clientSideScene/segments.ts
+  9) src/hooks/useModelingContext.ts -> src/components/ModelingMachineProvider.tsx -> src/components/Toolbar/Intersect.tsx -> src/components/SetHorVertDistanceModal.tsx -> src/lib/useCalculateKclExpression.ts
+  10) src/routes/Onboarding/index.tsx -> src/routes/Onboarding/Camera.tsx -> src/routes/Onboarding/utils.tsx

package.json

@@ -76,6 +76,7 @@
     "yargs": "^17.7.2"
   },
   "scripts": {
+    "prepare": "husky",
     "install:rust": "curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain none && source \"$HOME/.cargo/env\" && (cd rust && (rustup show active-toolchain || rustup toolchain install))",
     "install:rust:windows": "winget install Microsoft.VisualStudio.2022.Community --silent --override \"--wait --quiet --add ProductLang En-us --add Microsoft.VisualStudio.Workload.NativeDesktop --includeRecommended\" && winget install Rustlang.Rustup",
     "install:wasm-pack:sh": ". $HOME/.cargo/env && curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh -s -- -f",
@@ -114,6 +115,7 @@
     "circular-deps": "dpdm --no-warning --no-tree -T --skip-dynamic-imports=circular src/index.tsx",
     "circular-deps:overwrite": "npm run circular-deps | sed '$d' | grep -v '^npm run' > known-circular.txt",
     "circular-deps:diff": "./scripts/diff-circular-deps.sh",
+    "circular-deps:diff:nodejs": "npm run circular-deps:diff || node ./scripts/diff.js",
     "files:set-version": "echo \"$(jq --arg v \"$VERSION\" '.version=$v' package.json --indent 2)\" > package.json",
     "files:set-notes": "./scripts/set-files-notes.sh",
     "files:flip-to-nightly": "./scripts/flip-files-to-nightly.sh",
@@ -125,7 +127,7 @@
     "generate:machine-api": "npx openapi-typescript ./openapi/machine-api.json -o src/lib/machine-api.d.ts",
     "generate:samples-manifest": "cd public/kcl-samples && node generate-manifest.js",
     "tron:start": "electron-forge start",
-    "chrome:test": "PLATFORM=web NODE_ENV=development playwright test --config=playwright.config.ts --project='Google Chrome' --grep-invert='@snapshot'",
+    "chrome:test": "PLATFORM=web NODE_ENV=development playwright test --config=playwright.config.ts --project='Google Chrome' --grep-invert=@snapshot",
     "tronb:vite:dev": "vite build -c vite.main.config.ts -m development && vite build -c vite.preload.config.ts -m development && vite build -c vite.renderer.config.ts -m development",
     "tronb:vite:prod": "vite build -c vite.main.config.ts && vite build -c vite.preload.config.ts && vite build -c vite.renderer.config.ts",
     "tronb:package:dev": "npm run tronb:vite:dev && electron-builder --config electron-builder.yml",
@@ -135,15 +137,15 @@
     "test:snapshots": "PLATFORM=web NODE_ENV=development playwright test --config=playwright.config.ts --grep=@snapshot --trace=on --shard=1/1",
     "test:unit": "vitest run --mode development --exclude **/kclSamples.test.ts",
     "test:unit:kcl-samples": "vitest run --mode development ./src/lang/kclSamples.test.ts",
-    "test:playwright:electron": "playwright test --config=playwright.electron.config.ts --grep-invert='@snapshot'",
-    "test:playwright:electron:windows": "playwright test --config=playwright.electron.config.ts --grep-invert=\"@skipWin|@snapshot\" --quiet",
-    "test:playwright:electron:macos": "playwright test --config=playwright.electron.config.ts --grep-invert='@skipMacos|@snapshot' --quiet",
-    "test:playwright:electron:ubuntu": "playwright test --config=playwright.electron.config.ts --grep-invert='@skipLinux|@snapshot' --quiet",
-    "test:playwright:electron:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert='@snapshot'",
-    "test:playwright:electron:windows:local": "npm run tronb:vite:dev && set NODE_ENV='development' && playwright test --config=playwright.electron.config.ts --grep-invert=\"@skipWin|@snapshot\"",
-    "test:playwright:electron:macos:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert='@skipMacos|@snapshot'",
-    "test:playwright:electron:ubuntu:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert='@skipLinux|@snapshot'",
-    "test:playwright:electron:ubuntu:engine:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert='@skipLinux|@snapshot|@skipLocalEngine'",
+    "test:playwright:electron": "playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
+    "test:playwright:electron:windows": "playwright test --config=playwright.electron.config.ts --grep=@windows --quiet",
+    "test:playwright:electron:macos": "playwright test --config=playwright.electron.config.ts --grep=@macos --quiet",
+    "test:playwright:electron:ubuntu": "playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot --quiet",
+    "test:playwright:electron:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
+    "test:playwright:electron:windows:local": "npm run tronb:vite:dev && set NODE_ENV='development' && playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
+    "test:playwright:electron:macos:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
+    "test:playwright:electron:ubuntu:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
+    "test:playwright:electron:ubuntu:engine:local": "npm run tronb:vite:dev && NODE_ENV=development playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot|@skipLocalEngine",
     "test:unit:local": "npm run simpleserver:bg && npm run test:unit; kill-port 3000",
     "test:unit:kcl-samples:local": "npm run simpleserver:bg && npm run test:unit:kcl-samples; kill-port 3000"
   },

public/kcl-samples/bench/bench-parts.kcl

@@ -126,7 +126,7 @@ fn armRestProfile(plane, offset) {
 
 export fn armRest(plane, offset) {
   path = armRestPath(  offsetPlane(plane, offset = offset))
-  profile = armRestProfile(  offsetPlane(-XZ, offset = 20), offset)
+  profile = armRestProfile(  offsetPlane(-XZ, offset = 20), -offset)
   sweep(profile, path = path)
   return 0
 }

public/kcl-samples/bench/main.kcl

@@ -17,8 +17,8 @@ import armRest from "bench-parts.kcl"
 
 // Create the dividers, these hold the seat and back slats
 divider(YZ)
-divider(offsetPlane(-YZ, offset = benchLength / 2))
 divider(offsetPlane(YZ, offset = benchLength / 2))
+divider(offsetPlane(YZ, offset = -benchLength / 2))
 
 // Create the connectors to join the dividers
 connector(offsetPlane(YZ, offset = -benchLength / 2), benchLength)
@@ -30,5 +30,5 @@ seatSlats(offsetPlane(YZ, offset = -benchLength / 2 - (dividerThickness / 2)), b
 backSlats(offsetPlane(YZ, offset = -benchLength / 2 - (dividerThickness / 2)), benchLength + dividerThickness)
 
 // Create the arm rests
-armRest(-YZ, benchLength / 2)
-armRest(-YZ, -benchLength / 2)
+armRest(YZ, benchLength / 2)
+armRest(YZ, -benchLength / 2)

public/kcl-samples/dodecahedron/main.kcl

@@ -1,88 +1,79 @@
-// Hollow Dodecahedron
-// A regular dodecahedron or pentagonal dodecahedron is a dodecahedron composed of regular pentagonal faces, three meeting at each vertex. This example shows constructing the individual faces of the dodecahedron and extruding inwards.
+// Dodecahedron
+// A regular dodecahedron or pentagonal dodecahedron is a dodecahedron composed of regular pentagonal faces, three meeting at each vertex. This example shows constructing the a dodecahedron with a series of intersects.
 
 // Set units
 @settings(defaultLengthUnit = in)
 
-// Input parameters
-// circumscribed radius
-circR = 25
+// Define the dihedral angle for a regular dodecahedron
+dihedral = 116.565
 
-// Calculated parameters
-// Thickness of the dodecahedron
-wallThickness = circR * 0.2
-
-// Angle between faces in radians
-dihedral = acos(-(sqrt(5) / 5))
-
-// Inscribed radius
-inscR = circR / 15 * sqrt(75 + 30 * sqrt(5))
-
-// Pentagon edge length
-edgeL = 4 * circR / (sqrt(3) * (1 + sqrt(5)))
-
-// Pentagon radius
-pentR = edgeL / 2 / sin(toRadians(36))
-
-// Define a plane for the bottom angled face
-plane = {
-  origin = [
-    -inscR * cos(toRadians(toDegrees(dihedral) - 90)),
-    0,
-    inscR - (inscR * sin(toRadians(toDegrees(dihedral) - 90)))
-  ],
-  xAxis = [cos(dihedral), 0.0, sin(dihedral)],
-  yAxis = [0, 1, 0],
-  zAxis = [sin(dihedral), 0, -cos(dihedral)]
+// Create a face template function that makes a large thin cube
+fn createFaceTemplate(dither) {
+  baseSketch = startSketchOn(XY)
+    |> startProfileAt([-1000 - dither, -1000 - dither], %)
+    |> line(endAbsolute = [1000 + dither, -1000 - dither])
+    |> line(endAbsolute = [1000 + dither, 1000 + dither])
+    |> line(endAbsolute = [-1000 - dither, 1000 + dither])
+    |> close()
+  extruded = extrude(baseSketch, length = 1000 + dither + 1000)
+  return extruded
+    |> translate(x = 0, y = 0, z = -260 - dither)
 }
 
-// Create a regular pentagon inscribed in a circle of radius pentR
-bottomFace = startSketchOn(XY)
-  |> polygon(
-       radius = pentR,
-       numSides = 5,
-       center = [0, 0],
-       inscribed = true,
-     )
+// Define the rotations array with [pitch, roll, yaw, dither] for each face
+faceRotations = [
+  [0, 0, 0, 0],
+  // face1 - reference face
+  [dihedral, 0, 0, 0.1],
+  // face2
+  [dihedral, 0, 72, 0.2],
+  // face3
+  [dihedral, 0, 144, 0.3],
+  // face4
+  [dihedral, 0, 216, 0.4],
+  // face5
+  [dihedral, 0, 288, 0.5],
+  // face6
+  [180, 0, 0, 0.6],
+  // face7
+  [180 - dihedral, 0, 36, 0.7],
+  // face8
+  [180 - dihedral, 0, 108, 0.8],
+  // face9
+  [180 - dihedral, 0, 180, 0.9],
+  // face10
+  [180 - dihedral, 0, 252, 0.11],
+  // face11
+  [180 - dihedral, 0, 324, 0.12],
+  // face12
+]
 
-bottomSideFace = startSketchOn(plane)
-  |> polygon(
-       radius = pentR,
-       numSides = 5,
-       center = [0, 0],
-       inscribed = true,
-     )
+// Create faces by mapping over the rotations array
+dodecFaces = map(faceRotations, fn(rotation) {
+  return createFaceTemplate(rotation[3])
+    |> rotate(
+         pitch = rotation[0],
+         roll = rotation[1],
+         yaw = rotation[2],
+         global = true,
+       )
+})
 
-// Extrude the faces in each plane
-bottom = extrude(bottomFace, length = wallThickness)
-bottomSide = extrude(bottomSideFace, length = wallThickness)
+fn calculateArrayLength(arr) {
+  return reduce(arr, 0, fn(item, accumulator) {
+    return accumulator + 1
+  })
+}
 
-// Pattern the sides so we have a full dodecahedron
-bottomBowl = patternCircular3d(
-  bottomSide,
-  instances = 5,
-  axis = [0, 0, 1],
-  center = [0, 0, 0],
-  arcDegrees = 360,
-  rotateDuplicates = true,
-)
+fn createIntersection(solids) {
+  fn reduceIntersect(previous, current) {
+    return intersect([previous, current])
+  }
+  lastIndex = calculateArrayLength(solids) - 1
+  lastSolid = solids[lastIndex]
+  remainingSolids = pop(solids)
+  return reduce(remainingSolids, lastSolid, reduceIntersect)
+}
 
-// Pattern the bottom to create the top face
-patternCircular3d(
-  bottom,
-  instances = 2,
-  axis = [0, 1, 0],
-  center = [0, 0, inscR],
-  arcDegrees = 360,
-  rotateDuplicates = true,
-)
-
-// Pattern the bottom angled faces to create the top
-patternCircular3d(
-  bottomBowl,
-  instances = 2,
-  axis = [0, 1, 0],
-  center = [0, 0, inscR],
-  arcDegrees = 360,
-  rotateDuplicates = true,
-)
+// Apply intersection to all faces
+createIntersection(dodecFaces)

public/kcl-samples/gridfinity-bins-stacking-lip/main.kcl

@@ -202,19 +202,17 @@ plane000 = {
     height + binHeight * countBinHeight
   ],
   xAxis = [0.0, 1.0, 0.0],
-  yAxis = [0.0, 0.0, 1.0],
-  zAxis = [1.0, 0.0, 0.0]
+  yAxis = [0.0, 0.0, 1.0]
 }
 
 plane001 = {
   origin = [
     0.0,
-    cornerRadius,
+    countBinLength * (binLength + 2 * binTol) - cornerRadius,
     height + binHeight * countBinHeight
   ],
   xAxis = [1.0, 0.0, 0.0],
-  yAxis = [0.0, 0.0, 1.0],
-  zAxis = [0.0, 1.0, 0.0]
+  yAxis = [0.0, 0.0, 1.0]
 }
 
 plane002 = {
@@ -224,8 +222,7 @@ plane002 = {
     height + binHeight * countBinHeight
   ],
   xAxis = [0.0, 1.0, 0.0],
-  yAxis = [0.0, 0.0, 1.0],
-  zAxis = [1.0, 0.0, 0.0]
+  yAxis = [0.0, 0.0, 1.0]
 }
 
 // Extrude a single side of the lip of the bin

public/kcl-samples/manifest.json

@@ -66,8 +66,8 @@
     "file": "main.kcl",
     "pathFromProjectDirectoryToFirstFile": "dodecahedron/main.kcl",
     "multipleFiles": false,
-    "title": "Hollow Dodecahedron",
-    "description": "A regular dodecahedron or pentagonal dodecahedron is a dodecahedron composed of regular pentagonal faces, three meeting at each vertex. This example shows constructing the individual faces of the dodecahedron and extruding inwards."
+    "title": "Dodecahedron",
+    "description": "A regular dodecahedron or pentagonal dodecahedron is a dodecahedron composed of regular pentagonal faces, three meeting at each vertex. This example shows constructing the a dodecahedron with a series of intersects."
   },
   {
     "file": "main.kcl",

public/kcl-samples/multi-axis-robot/globals.kcl

@@ -4,10 +4,10 @@
 @settings(defaultLengthUnit = in)
 
 // Axis Angles
-export axisJ4 = 25
-export axisJ3 = 60
-export axisJ2 = 110
-export axisJ1 = 80
+export axisJ4 = 25deg
+export axisJ3 = 60deg
+export axisJ2 = 110deg
+export axisJ1 = 80deg
 
 // Robot Arm Base
 export basePlateRadius = 5
@@ -30,29 +30,26 @@ export axisJ3CArmThickness = 2.5
 export plane001 = {
   origin = [0.0, 0.0, baseHeight - 1.5 + 0.1],
   xAxis = [1.0, 0.0, 0.0],
-  yAxis = [0.0, 1.0, 0.0],
-  zAxis = [0.0, 0.0, 1.0]
+  yAxis = [0.0, 1.0, 0.0]
 }
 
 export plane002 = {
   origin = [0.0, 0.0, 0.0],
   xAxis = [
-    sin(toRadians(axisJ1)),
-    cos(toRadians(axisJ1)),
+    sin(axisJ1): number(in),
+    cos(axisJ1): number(in),
     0.0
   ],
-  yAxis = [0.0, 0.0, 1.0],
-  zAxis = [1.0, 0.0, 0.0]
+  yAxis = [0.0, 0.0, 1.0]
 }
 
 // Define Plane to Move J2 Axis Robot Arm
 export plane003 = {
   origin = [-0.1, 0.0, 0.0],
   xAxis = [
-    sin(toRadians(axisJ1)),
-    cos(toRadians(axisJ1)),
+    sin(axisJ1): number(in),
+    cos(axisJ1): number(in),
     0.0
   ],
-  yAxis = [0.0, 0.0, 1.0],
-  zAxis = [1.0, 0.0, 0.0]
+  yAxis = [0.0, 0.0, 1.0]
 }

public/kcl-samples/poopy-shoe/main.kcl

@@ -62,8 +62,7 @@ customPlane = {
     z = 0
   },
   xAxis = { x = 1, y = 0, z = 0 },
-  yAxis = { x = 0, y = 0, z = 1 },
-  zAxis = { x = 0, y = -1, z = 0 }
+  yAxis = { x = 0, y = 0, z = 1 }
 }
 sketch003 = startSketchOn(customPlane)
   |> startProfileAt([0, 0], %)
@@ -98,19 +97,18 @@ customPlane2 = {
     y = 0,
     z = 0
   },
-  xAxis = { x = 0, y = -1, z = 0 },
-  yAxis = { x = 0, y = 0, z = 1 },
-  zAxis = { x = 1, y = 0, z = 0 }
+  xAxis = { x = 0, y = 1, z = 0 },
+  yAxis = { x = 0, y = 0, z = 1 }
 }
 sketch005 = startSketchOn(customPlane2)
   |> startProfileAt([0, 0], %)
   |> yLine(endAbsolute = height)
-  |> xLine(endAbsolute = wallsWidth)
+  |> xLine(endAbsolute = -wallsWidth)
   |> tangentialArc(endAbsolute = [
-       (frontLength - wallsWidth) / 2 + wallsWidth,
+       -1 * ((frontLength - wallsWidth) / 2 + wallsWidth),
        height - ((height - exitHeight) / 2)
      ])
-  |> tangentialArc(endAbsolute = [frontLength, exitHeight])
+  |> tangentialArc(endAbsolute = [-frontLength, exitHeight])
   |> yLine(endAbsolute = 0, tag = $seg03)
   |> close()
   |> extrude(length = wallThickness)
@@ -138,8 +136,7 @@ customPlane3 = {
     z = wallThickness
   },
   xAxis = { x = 0, y = -1, z = 0 },
-  yAxis = { x = 1, y = 0, z = 0 },
-  zAxis = { x = 0, y = 0, z = 1 }
+  yAxis = { x = 1, y = 0, z = 0 }
 }
 
 sketch008 = startSketchOn(customPlane3)

rust/.config/nextest.toml

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

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

@@ -6,11 +6,12 @@
 mod tests;
 mod unbox;
 
-use std::collections::HashMap;
+use std::{collections::HashMap, fs};
 
 use convert_case::Casing;
 use inflector::{cases::camelcase::to_camel_case, Inflector};
 use once_cell::sync::Lazy;
+use proc_macro2::Span;
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use regex::Regex;
 use serde::Deserialize;
@@ -21,6 +22,16 @@ use syn::{
 };
 use unbox::unbox;
 
+#[proc_macro_attribute]
+pub fn stdlib(attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    do_output(do_stdlib(attr.into(), item.into()))
+}
+
+#[proc_macro_attribute]
+pub fn for_each_std_mod(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    do_for_each_std_mod(item.into()).into()
+}
+
 /// Describes an argument of a stdlib function.
 #[derive(Deserialize, Debug)]
 struct ArgMetadata {
@@ -73,11 +84,6 @@ struct StdlibMetadata {
     args: HashMap<String, ArgMetadata>,
 }
 
-#[proc_macro_attribute]
-pub fn stdlib(attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    do_output(do_stdlib(attr.into(), item.into()))
-}
-
 fn do_stdlib(
     attr: proc_macro2::TokenStream,
     item: proc_macro2::TokenStream,
@@ -86,6 +92,31 @@ fn do_stdlib(
     do_stdlib_inner(metadata, attr, item)
 }
 
+fn do_for_each_std_mod(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
+    let item: syn::ItemFn = syn::parse2(item.clone()).unwrap();
+    let mut result = proc_macro2::TokenStream::new();
+    for name in fs::read_dir("kcl-lib/std").unwrap().filter_map(|e| {
+        let e = e.unwrap();
+        let filename = e.file_name();
+        filename.to_str().unwrap().strip_suffix(".kcl").map(str::to_owned)
+    }) {
+        let mut item = item.clone();
+        item.sig.ident = syn::Ident::new(&format!("{}_{}", item.sig.ident, name), Span::call_site());
+        let stmts = &item.block.stmts;
+        //let name = format!("\"{name}\"");
+        let block = quote! {
+            {
+                const STD_MOD_NAME: &str = #name;
+                #(#stmts)*
+            }
+        };
+        item.block = Box::new(syn::parse2(block).unwrap());
+        result.extend(Some(item.into_token_stream()));
+    }
+
+    result
+}
+
 fn do_output(res: Result<(proc_macro2::TokenStream, Vec<Error>), Error>) -> proc_macro::TokenStream {
     match res {
         Err(err) => err.to_compile_error().into(),
@@ -671,6 +702,7 @@ fn normalize_comment_string(s: String) -> Vec<String> {
 
 /// Represent an item without concern for its body which may (or may not)
 /// contain syntax errors.
+#[derive(Clone)]
 struct ItemFnForSignature {
     pub attrs: Vec<Attribute>,
     pub vis: Visibility,

rust/kcl-lib/README.md

@@ -19,6 +19,30 @@ We've built a lot of tooling to make contributing to KCL easier. If you are inte
 11. Run `just redo-kcl-stdlib-docs` to generate new Markdown documentation for your function that will be used [to generate docs on our website](https://zoo.dev/docs/kcl).
 12. Create a PR in GitHub.
 
+## Making a Simulation Test
+
+If you have KCL code that you want to test, simulation tests are the preferred way to do that.
+
+Make a new sim test. Replace `foo_bar` with the snake case name of your test. The name needs to be unique.
+
+```shell
+just new-sim-test foo_bar
+```
+
+It will show the commands it ran, including the path to a new file `foo_bar/input.kcl`. Edit that with your KCL. If you need additional KCL files to import, include them in this directory.
+
+Then run it.
+
+```shell
+just overwrite-sim-test foo_bar
+```
+
+The above should create a bunch of output files in the same directory.
+
+Make sure you actually look at them. Specifically, if there's an `execution_error.snap`, it means the execution failed. Depending on the test, this may be what you expect. But if it's not, delete the snap file and run it again.
+
+When it looks good, commit all the files, including `input.kcl`, generated output files in the test directory, and changes to `simulation_tests.rs`.
+
 ## Bumping the version
 
 If you bump the version of kcl-lib and push it to crates, be sure to update the repos we own that use it as well. These are:

rust/kcl-lib/e2e/executor/inputs/big_number_angle_to_match_length_x.kcl

@@ -1,9 +0,0 @@
-const part001 = startSketchOn(XY)
-  |> startProfileAt([0, 0], %)
-  |> line(end = [1, 3.82], tag = $seg01)
-  |> angled(
-       angle = -angleToMatchLengthX(seg01, 3, %),
-       endAbsoluteX = 3,
-     )
-  |> close()
-  |> extrude(length = 10)

rust/kcl-lib/e2e/executor/inputs/big_number_angle_to_match_length_y.kcl

@@ -1,9 +0,0 @@
-const part001 = startSketchOn(XY)
-  |> startProfileAt([0, 0], %)
-  |> line(end = [1, 3.82], tag = $seg01)
-  |> angledLine(
-       angle = -angleToMatchLengthY(seg01, 3, %),
-       endAbsoluteX = 3,
-     )
-  |> close()
-  |> extrude(length = 10)

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

@@ -61,8 +61,10 @@ impl CollectionVisitor {
                         format!("std::{}::", self.name)
                     };
                     let mut dd = match var.kind {
-                        VariableKind::Fn => DocData::Fn(FnData::from_ast(var, qual_name, preferred_prefix)),
-                        VariableKind::Const => DocData::Const(ConstData::from_ast(var, qual_name, preferred_prefix)),
+                        VariableKind::Fn => DocData::Fn(FnData::from_ast(var, qual_name, preferred_prefix, name)),
+                        VariableKind::Const => {
+                            DocData::Const(ConstData::from_ast(var, qual_name, preferred_prefix, name))
+                        }
                     };
 
                     dd.with_meta(&var.outer_attrs);
@@ -79,7 +81,7 @@ impl CollectionVisitor {
                     } else {
                         format!("std::{}::", self.name)
                     };
-                    let mut dd = DocData::Ty(TyData::from_ast(ty, qual_name, preferred_prefix));
+                    let mut dd = DocData::Ty(TyData::from_ast(ty, qual_name, preferred_prefix, name));
 
                     dd.with_meta(&ty.outer_attrs);
                     for a in &ty.outer_attrs {
@@ -114,6 +116,16 @@ impl DocData {
         }
     }
 
+    /// The name of the module in which the item is declared, e.g., `sketch`
+    #[allow(dead_code)]
+    pub fn module_name(&self) -> &str {
+        match self {
+            DocData::Fn(f) => &f.module_name,
+            DocData::Const(c) => &c.module_name,
+            DocData::Ty(t) => &t.module_name,
+        }
+    }
+
     #[allow(dead_code)]
     pub fn file_name(&self) -> String {
         match self {
@@ -132,6 +144,7 @@ impl DocData {
         }
     }
 
+    /// The path to the module through which the item is accessed, e.g., `std::sketch`
     #[allow(dead_code)]
     pub fn mod_name(&self) -> String {
         let q = match self {
@@ -217,6 +230,8 @@ pub struct ConstData {
     /// Code examples.
     /// These are tested and we know they compile and execute.
     pub examples: Vec<(String, ExampleProperties)>,
+
+    pub module_name: String,
 }
 
 impl ConstData {
@@ -224,6 +239,7 @@ impl ConstData {
         var: &crate::parsing::ast::types::VariableDeclaration,
         mut qual_name: String,
         preferred_prefix: &str,
+        module_name: &str,
     ) -> Self {
         assert_eq!(var.kind, crate::parsing::ast::types::VariableKind::Const);
 
@@ -263,6 +279,7 @@ impl ConstData {
             summary: None,
             description: None,
             examples: Vec::new(),
+            module_name: module_name.to_owned(),
         }
     }
 
@@ -334,6 +351,8 @@ pub struct FnData {
     pub examples: Vec<(String, ExampleProperties)>,
     #[allow(dead_code)]
     pub referenced_types: Vec<String>,
+
+    pub module_name: String,
 }
 
 impl FnData {
@@ -341,6 +360,7 @@ impl FnData {
         var: &crate::parsing::ast::types::VariableDeclaration,
         mut qual_name: String,
         preferred_prefix: &str,
+        module_name: &str,
     ) -> Self {
         assert_eq!(var.kind, crate::parsing::ast::types::VariableKind::Fn);
         let crate::parsing::ast::types::Expr::FunctionExpression(expr) = &var.declaration.init else {
@@ -375,6 +395,7 @@ impl FnData {
             description: None,
             examples: Vec::new(),
             referenced_types: referenced_types.into_iter().collect(),
+            module_name: module_name.to_owned(),
         }
     }
 
@@ -654,6 +675,8 @@ pub struct TyData {
     pub examples: Vec<(String, ExampleProperties)>,
     #[allow(dead_code)]
     pub referenced_types: Vec<String>,
+
+    pub module_name: String,
 }
 
 impl TyData {
@@ -661,6 +684,7 @@ impl TyData {
         ty: &crate::parsing::ast::types::TypeDeclaration,
         mut qual_name: String,
         preferred_prefix: &str,
+        module_name: &str,
     ) -> Self {
         let name = ty.name.name.clone();
         qual_name.push_str(&name);
@@ -684,6 +708,7 @@ impl TyData {
             description: None,
             examples: Vec::new(),
             referenced_types: referenced_types.into_iter().collect(),
+            module_name: module_name.to_owned(),
         }
     }
 
@@ -1009,6 +1034,8 @@ fn collect_type_names_from_primitive(ty: &PrimitiveType) -> String {
 
 #[cfg(test)]
 mod test {
+    use kcl_derive_docs::for_each_std_mod;
+
     use super::*;
 
     #[test]
@@ -1047,18 +1074,28 @@ mod test {
         );
     }
 
-    #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-    async fn test_examples() -> miette::Result<()> {
+    #[for_each_std_mod]
+    #[tokio::test(flavor = "multi_thread")]
+    async fn kcl_test_examples() {
         let std = walk_prelude();
+        let mut errs = Vec::new();
         for d in std {
+            if d.module_name() != STD_MOD_NAME {
+                continue;
+            }
+
             for (i, eg) in d.examples().enumerate() {
                 let result = match crate::test_server::execute_and_snapshot(eg, None).await {
                     Err(crate::errors::ExecError::Kcl(e)) => {
-                        return Err(miette::Report::new(crate::errors::Report {
-                            error: e.error,
-                            filename: format!("{}{i}", d.name()),
-                            kcl_source: eg.to_string(),
-                        }));
+                        errs.push(
+                            miette::Report::new(crate::errors::Report {
+                                error: e.error,
+                                filename: format!("{}{i}", d.name()),
+                                kcl_source: eg.to_string(),
+                            })
+                            .to_string(),
+                        );
+                        continue;
                     }
                     Err(other_err) => panic!("{}", other_err),
                     Ok(img) => img,
@@ -1071,6 +1108,8 @@ mod test {
             }
         }
 
-        Ok(())
+        if !errs.is_empty() {
+            panic!("{}", errs.join("\n\n"));
+        }
     }
 }

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

@@ -129,6 +129,8 @@ impl StdLibFnArg {
         };
         if (self.type_ == "Sketch"
             || self.type_ == "[Sketch]"
+            || self.type_ == "Geometry"
+            || self.type_ == "GeometryWithImportedGeometry"
             || self.type_ == "Solid"
             || self.type_ == "[Solid]"
             || self.type_ == "SketchSurface"
@@ -502,6 +504,8 @@ pub trait StdLibFn: std::fmt::Debug + Send + Sync {
     fn to_autocomplete_snippet(&self) -> Result<String> {
         if self.name() == "loft" {
             return Ok("loft([${0:sketch000}, ${1:sketch001}])".to_string());
+        } else if self.name() == "clone" {
+            return Ok("clone(${0:part001})".to_string());
         } else if self.name() == "union" {
             return Ok("union([${0:extrude001}, ${1:extrude002}])".to_string());
         } else if self.name() == "subtract" {
@@ -1089,6 +1093,14 @@ mod tests {
         );
     }
 
+    #[test]
+    #[allow(clippy::literal_string_with_formatting_args)]
+    fn get_autocomplete_snippet_clone() {
+        let clone_fn: Box<dyn StdLibFn> = Box::new(crate::std::clone::Clone);
+        let snippet = clone_fn.to_autocomplete_snippet().unwrap();
+        assert_eq!(snippet, r#"clone(${0:part001})"#);
+    }
+
     // We want to test the snippets we compile at lsp start.
     #[test]
     fn get_all_stdlib_autocomplete_snippets() {

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

@@ -459,7 +459,7 @@ impl ExecutorContext {
                 exec_state.add_path_to_source_id(resolved_path.clone(), id);
                 let format = super::import::format_from_annotations(attrs, path, source_range)?;
                 let geom = super::import::import_foreign(path, format, exec_state, self, source_range).await?;
-                exec_state.add_module(id, resolved_path, ModuleRepr::Foreign(geom));
+                exec_state.add_module(id, resolved_path, ModuleRepr::Foreign(geom, None));
                 Ok(id)
             }
             ImportPath::Std { .. } => {
@@ -501,7 +501,7 @@ impl ExecutorContext {
                     *cache = Some((val, er, items.clone()));
                     (er, items)
                 }),
-            ModuleRepr::Foreign(geom) => Err(KclError::Semantic(KclErrorDetails {
+            ModuleRepr::Foreign(geom, _) => Err(KclError::Semantic(KclErrorDetails {
                 message: "Cannot import items from foreign modules".to_owned(),
                 source_ranges: vec![geom.source_range],
             })),
@@ -546,9 +546,20 @@ impl ExecutorContext {
                     Err(e) => Err(e),
                 }
             }
-            ModuleRepr::Foreign(geom) => super::import::send_to_engine(geom.clone(), self)
-                .await
-                .map(|geom| Some(KclValue::ImportedGeometry(geom))),
+            ModuleRepr::Foreign(_, Some(imported)) => Ok(Some(imported.clone())),
+            ModuleRepr::Foreign(geom, cached) => {
+                let result = super::import::send_to_engine(geom.clone(), self)
+                    .await
+                    .map(|geom| Some(KclValue::ImportedGeometry(geom)));
+
+                match result {
+                    Ok(val) => {
+                        *cached = val.clone();
+                        Ok(val)
+                    }
+                    Err(e) => Err(e),
+                }
+            }
             ModuleRepr::Dummy => unreachable!(),
         };
 
@@ -1142,9 +1153,15 @@ impl Node<UnaryExpression> {
             }
             KclValue::Plane { value } => {
                 let mut plane = value.clone();
-                plane.z_axis.x *= -1.0;
-                plane.z_axis.y *= -1.0;
-                plane.z_axis.z *= -1.0;
+                if plane.x_axis.x != 0.0 {
+                    plane.x_axis.x *= -1.0;
+                }
+                if plane.x_axis.y != 0.0 {
+                    plane.x_axis.y *= -1.0;
+                }
+                if plane.x_axis.z != 0.0 {
+                    plane.x_axis.z *= -1.0;
+                }
 
                 plane.value = PlaneType::Uninit;
                 plane.id = exec_state.next_uuid();
@@ -2637,7 +2654,6 @@ p = {
   origin = { x = 0, y = 0, z = 0 },
   xAxis = { x = 1, y = 0, z = 0 },
   yAxis = { x = 0, y = 1, z = 0 },
-  zAxis = { x = 0, y = 0, z = 1 }
 }: Plane
 p2 = -p
 "#;
@@ -2649,7 +2665,11 @@ p2 = -p
             .get_from("p2", result.mem_env, SourceRange::default(), 0)
             .unwrap()
         {
-            KclValue::Plane { value } => assert_eq!(value.z_axis.z, -1.0),
+            KclValue::Plane { value } => {
+                assert_eq!(value.x_axis.x, -1.0);
+                assert_eq!(value.x_axis.y, 0.0);
+                assert_eq!(value.x_axis.z, 0.0);
+            }
             _ => unreachable!(),
         }
     }

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

@@ -47,6 +47,29 @@ impl Geometry {
     }
 }
 
+/// A geometry including an imported geometry.
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[ts(export)]
+#[serde(tag = "type")]
+pub enum GeometryWithImportedGeometry {
+    Sketch(Sketch),
+    Solid(Solid),
+    ImportedGeometry(Box<ImportedGeometry>),
+}
+
+impl GeometryWithImportedGeometry {
+    pub async fn id(&mut self, ctx: &ExecutorContext) -> Result<uuid::Uuid, KclError> {
+        match self {
+            GeometryWithImportedGeometry::Sketch(s) => Ok(s.id),
+            GeometryWithImportedGeometry::Solid(e) => Ok(e.id),
+            GeometryWithImportedGeometry::ImportedGeometry(i) => {
+                let id = i.id(ctx).await?;
+                Ok(id)
+            }
+        }
+    }
+}
+
 /// A set of geometry.
 #[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
@@ -262,8 +285,6 @@ pub struct Plane {
     pub x_axis: Point3d,
     /// What should the plane's Y axis be?
     pub y_axis: Point3d,
-    /// The z-axis (normal).
-    pub z_axis: Point3d,
     #[serde(skip)]
     pub meta: Vec<Metadata>,
 }
@@ -296,13 +317,6 @@ impl Plane {
                             z: 0.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: 0.0,
-                            y: 0.0,
-                            z: 1.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::XY,
                 Self {
@@ -315,7 +329,7 @@ impl Plane {
                         },
                     x_axis:
                         Point3d {
-                            x: 1.0,
+                            x: -1.0,
                             y: 0.0,
                             z: 0.0,
                             units: UnitLen::Mm,
@@ -327,13 +341,6 @@ impl Plane {
                             z: 0.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: 0.0,
-                            y: 0.0,
-                            z: -1.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::NegXY,
                 Self {
@@ -358,13 +365,6 @@ impl Plane {
                             z: 1.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: 0.0,
-                            y: -1.0,
-                            z: 0.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::XZ,
                 Self {
@@ -377,7 +377,7 @@ impl Plane {
                         },
                     x_axis:
                         Point3d {
-                            x: 1.0,
+                            x: -1.0,
                             y: 0.0,
                             z: 0.0,
                             units: UnitLen::Mm,
@@ -389,13 +389,6 @@ impl Plane {
                             z: 1.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: 0.0,
-                            y: 1.0,
-                            z: 0.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::NegXZ,
                 Self {
@@ -420,13 +413,6 @@ impl Plane {
                             z: 1.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: 1.0,
-                            y: 0.0,
-                            z: 0.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::YZ,
                 Self {
@@ -440,7 +426,7 @@ impl Plane {
                     x_axis:
                         Point3d {
                             x: 0.0,
-                            y: 1.0,
+                            y: -1.0,
                             z: 0.0,
                             units: UnitLen::Mm,
                         },
@@ -451,13 +437,6 @@ impl Plane {
                             z: 1.0,
                             units: UnitLen::Mm,
                         },
-                    z_axis:
-                        Point3d {
-                            x: -1.0,
-                            y: 0.0,
-                            z: 0.0,
-                            units: UnitLen::Mm,
-                        },
                     ..
                 } => return PlaneData::NegYZ,
                 _ => {}
@@ -468,7 +447,6 @@ impl Plane {
             origin: self.origin,
             x_axis: self.x_axis,
             y_axis: self.y_axis,
-            z_axis: self.z_axis,
         }
     }
 
@@ -481,7 +459,6 @@ impl Plane {
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
                 x_axis: Point3d::new(1.0, 0.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 1.0, 0.0, UnitLen::Mm),
-                z_axis: Point3d::new(0.0, 0.0, 1.0, UnitLen::Mm),
                 value: PlaneType::XY,
                 meta: vec![],
             },
@@ -489,9 +466,8 @@ impl Plane {
                 id,
                 artifact_id: id.into(),
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
-                x_axis: Point3d::new(1.0, 0.0, 0.0, UnitLen::Mm),
+                x_axis: Point3d::new(-1.0, 0.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 1.0, 0.0, UnitLen::Mm),
-                z_axis: Point3d::new(0.0, 0.0, -1.0, UnitLen::Mm),
                 value: PlaneType::XY,
                 meta: vec![],
             },
@@ -501,7 +477,6 @@ impl Plane {
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
                 x_axis: Point3d::new(1.0, 0.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 0.0, 1.0, UnitLen::Mm),
-                z_axis: Point3d::new(0.0, -1.0, 0.0, UnitLen::Mm),
                 value: PlaneType::XZ,
                 meta: vec![],
             },
@@ -511,7 +486,6 @@ impl Plane {
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
                 x_axis: Point3d::new(-1.0, 0.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 0.0, 1.0, UnitLen::Mm),
-                z_axis: Point3d::new(0.0, 1.0, 0.0, UnitLen::Mm),
                 value: PlaneType::XZ,
                 meta: vec![],
             },
@@ -521,7 +495,6 @@ impl Plane {
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
                 x_axis: Point3d::new(0.0, 1.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 0.0, 1.0, UnitLen::Mm),
-                z_axis: Point3d::new(1.0, 0.0, 0.0, UnitLen::Mm),
                 value: PlaneType::YZ,
                 meta: vec![],
             },
@@ -529,18 +502,12 @@ impl Plane {
                 id,
                 artifact_id: id.into(),
                 origin: Point3d::new(0.0, 0.0, 0.0, UnitLen::Mm),
-                x_axis: Point3d::new(0.0, 1.0, 0.0, UnitLen::Mm),
+                x_axis: Point3d::new(0.0, -1.0, 0.0, UnitLen::Mm),
                 y_axis: Point3d::new(0.0, 0.0, 1.0, UnitLen::Mm),
-                z_axis: Point3d::new(-1.0, 0.0, 0.0, UnitLen::Mm),
                 value: PlaneType::YZ,
                 meta: vec![],
             },
-            PlaneData::Plane {
-                origin,
-                x_axis,
-                y_axis,
-                z_axis,
-            } => {
+            PlaneData::Plane { origin, x_axis, y_axis } => {
                 let id = exec_state.next_uuid();
                 Plane {
                     id,
@@ -548,7 +515,6 @@ impl Plane {
                     origin,
                     x_axis,
                     y_axis,
-                    z_axis,
                     value: PlaneType::Custom,
                     meta: vec![],
                 }
@@ -577,8 +543,6 @@ pub struct Face {
     pub x_axis: Point3d,
     /// What should the face's Y axis be?
     pub y_axis: Point3d,
-    /// The z-axis (normal).
-    pub z_axis: Point3d,
     /// The solid the face is on.
     pub solid: Box<Solid>,
     pub units: UnitLen,
@@ -656,7 +620,8 @@ impl Sketch {
                     adjust_camera: false,
                     planar_normal: if let SketchSurface::Plane(plane) = &self.on {
                         // We pass in the normal for the plane here.
-                        Some(plane.z_axis.into())
+                        let normal = plane.x_axis.cross(&plane.y_axis);
+                        Some(normal.into())
                     } else {
                         None
                     },
@@ -700,12 +665,6 @@ impl SketchSurface {
             SketchSurface::Face(face) => face.y_axis,
         }
     }
-    pub(crate) fn z_axis(&self) -> Point3d {
-        match self {
-            SketchSurface::Plane(plane) => plane.z_axis,
-            SketchSurface::Face(face) => face.z_axis,
-        }
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -807,7 +766,10 @@ pub struct Solid {
     /// Chamfers or fillets on this solid.
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub edge_cuts: Vec<EdgeCut>,
+    /// The units of the solid.
     pub units: UnitLen,
+    /// Is this a sectional solid?
+    pub sectional: bool,
     /// Metadata.
     #[serde(skip)]
     pub meta: Vec<Metadata>,
@@ -858,6 +820,13 @@ impl EdgeCut {
         }
     }
 
+    pub fn set_id(&mut self, id: uuid::Uuid) {
+        match self {
+            EdgeCut::Fillet { id: ref mut i, .. } => *i = id,
+            EdgeCut::Chamfer { id: ref mut i, .. } => *i = id,
+        }
+    }
+
     pub fn edge_id(&self) -> uuid::Uuid {
         match self {
             EdgeCut::Fillet { edge_id, .. } => *edge_id,
@@ -865,6 +834,13 @@ impl EdgeCut {
         }
     }
 
+    pub fn set_edge_id(&mut self, id: uuid::Uuid) {
+        match self {
+            EdgeCut::Fillet { edge_id: ref mut i, .. } => *i = id,
+            EdgeCut::Chamfer { edge_id: ref mut i, .. } => *i = id,
+        }
+    }
+
     pub fn tag(&self) -> Option<TagNode> {
         match self {
             EdgeCut::Fillet { tag, .. } => *tag.clone(),
@@ -929,6 +905,27 @@ impl Point3d {
     pub const fn is_zero(&self) -> bool {
         self.x == 0.0 && self.y == 0.0 && self.z == 0.0
     }
+
+    /// Calculate the cross product of this vector with another
+    pub fn cross(&self, other: &Self) -> Self {
+        let other = if other.units == self.units {
+            other
+        } else {
+            &Point3d {
+                x: self.units.adjust_to(other.x, self.units).0,
+                y: self.units.adjust_to(other.y, self.units).0,
+                z: self.units.adjust_to(other.z, self.units).0,
+                units: self.units,
+            }
+        };
+
+        Self {
+            x: self.y * other.z - self.z * other.y,
+            y: self.z * other.x - self.x * other.z,
+            z: self.x * other.y - self.y * other.x,
+            units: self.units,
+        }
+    }
 }
 
 impl From<[TyF64; 3]> for Point3d {
@@ -1135,6 +1132,19 @@ pub enum Path {
         /// True if the arc is counterclockwise.
         ccw: bool,
     },
+    /// An involute of a circle of start_radius ending at end_radius
+    CircularInvolute {
+        #[serde(flatten)]
+        base: BasePath,
+        /// The radius of the base circle of the involute
+        start_radius: f64,
+        /// The radius that the involute ends at
+        end_radius: f64,
+        /// Angle about which the whole involute is rotated
+        angle: f64,
+        /// If true, the path segment starts at the end radius and goes towards the start radius
+        reverse: bool,
+    },
 }
 
 /// What kind of path is this?
@@ -1149,6 +1159,7 @@ enum PathType {
     Horizontal,
     AngledLineTo,
     Arc,
+    CircularInvolute,
 }
 
 impl From<&Path> for PathType {
@@ -1164,6 +1175,7 @@ impl From<&Path> for PathType {
             Path::Base { .. } => Self::Base,
             Path::Arc { .. } => Self::Arc,
             Path::ArcThreePoint { .. } => Self::Arc,
+            Path::CircularInvolute { .. } => Self::CircularInvolute,
         }
     }
 }
@@ -1181,6 +1193,23 @@ impl Path {
             Path::CircleThreePoint { base, .. } => base.geo_meta.id,
             Path::Arc { base, .. } => base.geo_meta.id,
             Path::ArcThreePoint { base, .. } => base.geo_meta.id,
+            Path::CircularInvolute { base, .. } => base.geo_meta.id,
+        }
+    }
+
+    pub fn set_id(&mut self, id: uuid::Uuid) {
+        match self {
+            Path::ToPoint { base } => base.geo_meta.id = id,
+            Path::Horizontal { base, .. } => base.geo_meta.id = id,
+            Path::AngledLineTo { base, .. } => base.geo_meta.id = id,
+            Path::Base { base } => base.geo_meta.id = id,
+            Path::TangentialArcTo { base, .. } => base.geo_meta.id = id,
+            Path::TangentialArc { base, .. } => base.geo_meta.id = id,
+            Path::Circle { base, .. } => base.geo_meta.id = id,
+            Path::CircleThreePoint { base, .. } => base.geo_meta.id = id,
+            Path::Arc { base, .. } => base.geo_meta.id = id,
+            Path::ArcThreePoint { base, .. } => base.geo_meta.id = id,
+            Path::CircularInvolute { base, .. } => base.geo_meta.id = id,
         }
     }
 
@@ -1196,6 +1225,7 @@ impl Path {
             Path::CircleThreePoint { base, .. } => base.tag.clone(),
             Path::Arc { base, .. } => base.tag.clone(),
             Path::ArcThreePoint { base, .. } => base.tag.clone(),
+            Path::CircularInvolute { base, .. } => base.tag.clone(),
         }
     }
 
@@ -1211,6 +1241,7 @@ impl Path {
             Path::CircleThreePoint { base, .. } => base,
             Path::Arc { base, .. } => base,
             Path::ArcThreePoint { base, .. } => base,
+            Path::CircularInvolute { base, .. } => base,
         }
     }
 
@@ -1272,6 +1303,15 @@ impl Path {
                 // TODO: Call engine utils to figure this out.
                 linear_distance(&self.get_base().from, &self.get_base().to)
             }
+            Self::CircularInvolute {
+                base: _,
+                start_radius,
+                end_radius,
+                ..
+            } => {
+                let angle = (end_radius * end_radius - start_radius * start_radius).sqrt() / start_radius;
+                0.5 * start_radius * angle * angle
+            }
         };
         TyF64::new(n, self.get_base().units.into())
     }
@@ -1288,6 +1328,7 @@ impl Path {
             Path::CircleThreePoint { base, .. } => Some(base),
             Path::Arc { base, .. } => Some(base),
             Path::ArcThreePoint { base, .. } => Some(base),
+            Path::CircularInvolute { base, .. } => Some(base),
         }
     }
 
@@ -1323,7 +1364,11 @@ impl Path {
                     radius: circle.radius,
                 }
             }
-            Path::ToPoint { .. } | Path::Horizontal { .. } | Path::AngledLineTo { .. } | Path::Base { .. } => {
+            Path::CircularInvolute { .. }
+            | Path::ToPoint { .. }
+            | Path::Horizontal { .. }
+            | Path::AngledLineTo { .. }
+            | Path::Base { .. } => {
                 let base = self.get_base();
                 GetTangentialInfoFromPathsResult::PreviousPoint(base.from)
             }
@@ -1350,6 +1395,7 @@ pub enum ExtrudeSurface {
     /// An extrude plane.
     ExtrudePlane(ExtrudePlane),
     ExtrudeArc(ExtrudeArc),
+    ExtrudeInvolute(ExtrudeInvolute),
     Chamfer(ChamferSurface),
     Fillet(FilletSurface),
 }
@@ -1410,11 +1456,26 @@ pub struct ExtrudeArc {
     pub geo_meta: GeoMeta,
 }
 
+/// An extruded involute.
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[ts(export)]
+#[serde(rename_all = "camelCase")]
+pub struct ExtrudeInvolute {
+    /// The face id for the extrude surface.
+    pub face_id: uuid::Uuid,
+    /// The tag.
+    pub tag: Option<Node<TagDeclarator>>,
+    /// Metadata.
+    #[serde(flatten)]
+    pub geo_meta: GeoMeta,
+}
+
 impl ExtrudeSurface {
     pub fn get_id(&self) -> uuid::Uuid {
         match self {
             ExtrudeSurface::ExtrudePlane(ep) => ep.geo_meta.id,
             ExtrudeSurface::ExtrudeArc(ea) => ea.geo_meta.id,
+            ExtrudeSurface::ExtrudeInvolute(ea) => ea.geo_meta.id,
             ExtrudeSurface::Fillet(f) => f.geo_meta.id,
             ExtrudeSurface::Chamfer(c) => c.geo_meta.id,
         }
@@ -1424,6 +1485,7 @@ impl ExtrudeSurface {
         match self {
             ExtrudeSurface::ExtrudePlane(ep) => ep.tag.clone(),
             ExtrudeSurface::ExtrudeArc(ea) => ea.tag.clone(),
+            ExtrudeSurface::ExtrudeInvolute(ea) => ea.tag.clone(),
             ExtrudeSurface::Fillet(f) => f.tag.clone(),
             ExtrudeSurface::Chamfer(c) => c.tag.clone(),
         }

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

@@ -9,8 +9,8 @@ use crate::{
     execution::{
         annotations::{SETTINGS, SETTINGS_UNIT_LENGTH},
         types::{NumericType, PrimitiveType, RuntimeType, UnitLen},
-        EnvironmentRef, ExecState, Face, Helix, ImportedGeometry, MetaSettings, Metadata, Plane, Sketch, Solid,
-        TagIdentifier,
+        EnvironmentRef, ExecState, Face, Geometry, GeometryWithImportedGeometry, Helix, ImportedGeometry, MetaSettings,
+        Metadata, Plane, Sketch, Solid, TagIdentifier,
     },
     parsing::ast::types::{
         DefaultParamVal, FunctionExpression, KclNone, Literal, LiteralValue, Node, TagDeclarator, TagNode,
@@ -611,3 +611,22 @@ impl KclValue {
         }
     }
 }
+
+impl From<Geometry> for KclValue {
+    fn from(value: Geometry) -> Self {
+        match value {
+            Geometry::Sketch(x) => Self::Sketch { value: Box::new(x) },
+            Geometry::Solid(x) => Self::Solid { value: Box::new(x) },
+        }
+    }
+}
+
+impl From<GeometryWithImportedGeometry> for KclValue {
+    fn from(value: GeometryWithImportedGeometry) -> Self {
+        match value {
+            GeometryWithImportedGeometry::Sketch(x) => Self::Sketch { value: Box::new(x) },
+            GeometryWithImportedGeometry::Solid(x) => Self::Solid { value: Box::new(x) },
+            GeometryWithImportedGeometry::ImportedGeometry(x) => Self::ImportedGeometry(*x),
+        }
+    }
+}