Rename and reorder contributor guide sections (#7387)

* Make web end-to-end tests exclusive with desktop

* Use double quotes to support Windows

CONTRIBUTING.md

@@ -1,6 +1,6 @@
 # Contributor Guide
 
-## Running a development build
+## Installing dependencies
 
 Install a node version manager such as [fnm](https://github.com/Schniz/fnm?tab=readme-ov-#installation).
 
@@ -31,7 +31,9 @@ npm run install:rust:windows
 npm run install:wasm-pack:cargo
 ```
 
-Then to build the WASM layer, run:
+## Building the app
+
+To build the WASM layer, run:
 
 ```
 # macOS/Linux
@@ -74,7 +76,7 @@ enable third-party cookies. You can enable third-party cookies by clicking on
 the eye with a slash through it in the URL bar, and clicking on "Enable
 Third-Party Cookies".
 
-## Desktop
+### Developing with Electron
 
 To spin up the desktop app, `npm install` and `npm run build:wasm` need to have been done before hand then:
 
@@ -88,114 +90,7 @@ Devtools can be opened with the usual Command-Option-I (macOS) or Ctrl-Shift-I (
 
 To package the app for your platform with electron-builder, run `npm run tronb:package:dev` (or `npm run tronb:package:prod` to point to the .env.production variables).
 
-## Checking out commits / Bisecting
-
-Which commands from setup are one off vs. need to be run every time?
-
-The following will need to be run when checking out a new commit and guarantees the build is not stale:
-
-```bash
-npm install
-npm run build:wasm
-npm start
-```
-
-## Before submitting a PR
-
-Before you submit a contribution PR to this repo, please ensure that:
-
-- There is a corresponding issue for the changes you want to make, so that discussion of approach can be had before work begins.
-- You have separated out refactoring commits from feature commits as much as possible
-- You have run all of the following commands locally:
-  - `npm run fmt`
-  - `npm run tsc`
-  - `npm run test`
-  - Here they are all together: `npm run fmt && npm run tsc && npm run test`
-
-## Release a new version
-
-#### 1. Create a 'Cut release $VERSION' issue
-
-It will be used to document changelog discussions and release testing.
-
-https://github.com/KittyCAD/modeling-app/issues/new
-
-#### 2. Push a new tag
-
-Decide on a `v`-prefixed semver `VERSION` (e.g. `v1.2.3`) with the team and tag the repo on the latest main:
-
-```
-git tag $VERSION --message=""
-git push origin $VERSION
-```
-
-This will trigger the `build-apps` workflow to set the version, build & sign the apps, and generate release files.
-
-The workflow should be listed right away [in this list](https://github.com/KittyCAD/modeling-app/actions/workflows/build-apps.yml?query=event%3Apush).
-
-#### 3. Manually test artifacts
-
-##### Release builds
-
-The release builds can be found under the `out-{arch}-{platform}` zip files, at the very bottom of the `build-apps` summary page for the workflow (triggered by the tag in step 2).
-
-Manually test against [this list](https://github.com/KittyCAD/modeling-app/issues/3588) across Windows, MacOS, Linux and posting results as comments in the issue.
-
-A prompt should show up asking for a downgrade to the last release version. Running through that at the end of testing
-and making sure the current release candidate has the ability to be updated to what electron-updater points to is critical,
-but what is actually being downloaded and installed isn't.
-If the prompt doesn't show up, start the app in command line to grab the electron-updater logs. This is likely an issue with the current build that needs addressing.
-
-```
-# Windows (PowerShell)
-& 'C:\Program Files\Zoo Design Studio\Zoo Design Studio.exe'
-
-# macOS
-/Applications/Zoo\ Modeling\ App.app/Contents/MacOS/Zoo\ Modeling\ App
-
-# Linux
-./Zoo Design Studio-{version}-{arch}-linux.AppImage
-```
-
-#### 4. Bump the KCL version
-
-Follow the instructions [here](./rust/README.md) to publish new crates.
-This ensures that the KCL accepted by the app is also accepted by the CLI.
-
-#### 5. Publish the release
-
-Head over to https://github.com/KittyCAD/modeling-app/releases/new, pick the newly created tag and type it in the **Release title** field as well.
-
-Click **Generate release notes** as a starting point to discuss the changelog in the issue. Once done, make sure **Set as the latest release** is checked, and click **Publish release**.
-
-A new `publish-apps-release` workflow will start and you should be able to find it [here](https://github.com/KittyCAD/modeling-app/actions?query=event%3Arelease). On success, the files will be uploaded to the public bucket as well as to the GitHub release, and the announcement on Discord will be sent.
-
-#### 6. Close the issue
-
-If everything is well and the release is out to the public, the issue tracking the release shall be closed.
-
-## Fuzzing the parser
-
-Make sure you install cargo fuzz:
-
-```bash
-$ cargo install cargo-fuzz
-```
-
-```bash
-$ cd rust/kcl-lib
-
-# list the fuzz targets
-$ cargo fuzz list
-
-# run the parser fuzzer
-$ cargo +nightly fuzz run parser
-```
-
-For more information on fuzzing you can check out
-[this guide](https://rust-fuzz.github.io/book/cargo-fuzz.html).
-
-## Tests
+## Running tests
 
 ### Playwright tests
 
@@ -313,8 +208,103 @@ then run tests that target the KCL language:
 npm run test:rust
 ```
 
+### Fuzzing the parser
+
+Make sure you install cargo fuzz:
+
+```bash
+$ cargo install cargo-fuzz
+```
+
+```bash
+$ cd rust/kcl-lib
+
+# list the fuzz targets
+$ cargo fuzz list
+
+# run the parser fuzzer
+$ cargo +nightly fuzz run parser
+```
+
+For more information on fuzzing you can check out
+[this guide](https://rust-fuzz.github.io/book/cargo-fuzz.html).
+
 ### Logging
 
 To display logging (to the terminal or console) set `ZOO_LOG=1`. This will log some warnings and simple performance metrics. To view these in test runs, use `-- --nocapture`.
 
 To enable memory metrics, build with `--features dhat-heap`.
+
+## Proposing changes
+
+Before you submit a contribution PR to this repo, please ensure that:
+
+- There is a corresponding issue for the changes you want to make, so that discussion of approach can be had before work begins.
+- You have separated out refactoring commits from feature commits as much as possible
+- You have run all of the following commands locally:
+  - `npm run fmt`
+  - `npm run tsc`
+  - `npm run test`
+  - Here they are all together: `npm run fmt && npm run tsc && npm run test`
+
+## Shipping releases
+
+#### 1. Create a 'Cut release $VERSION' issue
+
+It will be used to document changelog discussions and release testing.
+
+https://github.com/KittyCAD/modeling-app/issues/new
+
+#### 2. Push a new tag
+
+Decide on a `v`-prefixed semver `VERSION` (e.g. `v1.2.3`) with the team and tag the repo on the latest main:
+
+```
+git tag $VERSION --message=""
+git push origin $VERSION
+```
+
+This will trigger the `build-apps` workflow to set the version, build & sign the apps, and generate release files.
+
+The workflow should be listed right away [in this list](https://github.com/KittyCAD/modeling-app/actions/workflows/build-apps.yml?query=event%3Apush).
+
+#### 3. Manually test artifacts
+
+##### Release builds
+
+The release builds can be found under the `out-{arch}-{platform}` zip files, at the very bottom of the `build-apps` summary page for the workflow (triggered by the tag in step 2).
+
+Manually test against [this list](https://github.com/KittyCAD/modeling-app/issues/3588) across Windows, MacOS, Linux and posting results as comments in the issue.
+
+A prompt should show up asking for a downgrade to the last release version. Running through that at the end of testing
+and making sure the current release candidate has the ability to be updated to what electron-updater points to is critical,
+but what is actually being downloaded and installed isn't.
+If the prompt doesn't show up, start the app in command line to grab the electron-updater logs. This is likely an issue with the current build that needs addressing.
+
+```
+# Windows (PowerShell)
+& 'C:\Program Files\Zoo Design Studio\Zoo Design Studio.exe'
+
+# macOS
+/Applications/Zoo\ Modeling\ App.app/Contents/MacOS/Zoo\ Modeling\ App
+
+# Linux
+./Zoo Design Studio-{version}-{arch}-linux.AppImage
+```
+
+#### 4. Bump the KCL version
+
+Follow the instructions [here](./rust/README.md) to publish new crates.
+This ensures that the KCL accepted by the app is also accepted by the CLI.
+
+#### 5. Publish the release
+
+Head over to https://github.com/KittyCAD/modeling-app/releases/new, pick the newly created tag and type it in the **Release title** field as well.
+
+Click **Generate release notes** as a starting point to discuss the changelog in the issue. Once done, make sure **Set as the latest release** is checked, and click **Publish release**.
+
+A new `publish-apps-release` workflow will start and you should be able to find it [here](https://github.com/KittyCAD/modeling-app/actions?query=event%3Arelease). On success, the files will be uploaded to the public bucket as well as to the GitHub release, and the announcement on Discord will be sent.
+
+#### 6. Close the issue
+
+If everything is well and the release is out to the public, the issue tracking the release shall be closed.

docs/kcl-std/functions/std-appearance-hexString.md

@@ -1,24 +1,23 @@
 ---
 title: "appearance::hexString"
 subtitle: "Function in std::appearance"
-excerpt: ""
+excerpt: "Build a color from its red, green and blue components. These must be between 0 and 255."
 layout: manual
 ---
 
-
+Build a color from its red, green and blue components. These must be between 0 and 255.
 
 ```kcl
 appearance::hexString(@rgb: [number(_); 3]): string
 ```
 
-Build a color from its red, green and blue components.
-These must be between 0 and 255.
+
 
 ### Arguments
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `rgb` | [`[number(_); 3]`](/docs/kcl-std/types/std-types-number) |  | Yes |
+| `rgb` | [`[number(_); 3]`](/docs/kcl-std/types/std-types-number) | The red, blue and green components of the color. Must be between 0 and 255. | Yes |
 
 ### Returns
 

docs/kcl-std/functions/std-array-reduce.md

@@ -1,11 +1,11 @@
 ---
 title: "reduce"
 subtitle: "Function in std::array"
-excerpt: ""
+excerpt: "Take a starting value. Then, for each element of an array, calculate the next value, using the previous value and the element."
 layout: manual
 ---
 
-
+Take a starting value. Then, for each element of an array, calculate the next value, using the previous value and the element.
 
 ```kcl
 reduce(
@@ -15,8 +15,7 @@ reduce(
 ): any
 ```
 
-Take a starting value. Then, for each element of an array, calculate the next value,
-using the previous value and the element.
+
 
 ### Arguments
 
@@ -28,7 +27,7 @@ using the previous value and the element.
 
 ### Returns
 
-[`any`](/docs/kcl-std/types/std-types-any)
+[`any`](/docs/kcl-std/types/std-types-any) - The [`any`](/docs/kcl-std/types/std-types-any) type is the type of all possible values in KCL. I.e., if a function accepts an argument with type [`any`](/docs/kcl-std/types/std-types-any), then it can accept any value.
 
 
 ### Examples

docs/kcl-std/functions/std-assert.md

@@ -1,11 +1,11 @@
 ---
 title: "assert"
 subtitle: "Function in std"
-excerpt: ""
+excerpt: "Check a value meets some expected conditions at runtime. Program terminates with an error if conditions aren't met. If you provide multiple conditions, they will all be checked and all must be met."
 layout: manual
 ---
 
-
+Check a value meets some expected conditions at runtime. Program terminates with an error if conditions aren't met. If you provide multiple conditions, they will all be checked and all must be met.
 
 ```kcl
 assert(
@@ -20,8 +20,7 @@ assert(
 )
 ```
 
-Check a value meets some expected conditions at runtime. Program terminates with an error if conditions aren't met.
-If you provide multiple conditions, they will all be checked and all must be met.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-math-polar.md

@@ -1,11 +1,11 @@
 ---
 title: "polar"
 subtitle: "Function in std::math"
-excerpt: ""
+excerpt: "Convert polar/sphere (azimuth, elevation, distance) coordinates to cartesian (x/y/z grid) coordinates."
 layout: manual
 ---
 
-
+Convert polar/sphere (azimuth, elevation, distance) coordinates to cartesian (x/y/z grid) coordinates.
 
 ```kcl
 polar(
@@ -14,8 +14,7 @@ polar(
 ): Point2d
 ```
 
-Convert polar/sphere (azimuth, elevation, distance) coordinates to
-cartesian (x/y/z grid) coordinates.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-math-rem.md

@@ -1,11 +1,11 @@
 ---
 title: "rem"
 subtitle: "Function in std::math"
-excerpt: ""
+excerpt: "Compute the remainder after dividing `num` by `div`. If `num` is negative, the result will be too."
 layout: manual
 ---
 
-
+Compute the remainder after dividing `num` by `div`. If `num` is negative, the result will be too.
 
 ```kcl
 rem(
@@ -14,8 +14,7 @@ rem(
 ): number
 ```
 
-Compute the remainder after dividing `num` by `div`.
-If `num` is negative, the result will be too.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-sketch-angledLine.md

@@ -10,13 +10,13 @@ Draw a line segment relative to the current origin using the polar measure of so
 ```kcl
 angledLine(
   @sketch: Sketch,
-  angle: number,
-  length?: number,
-  lengthX?: number,
-  lengthY?: number,
-  endAbsoluteX?: number,
-  endAbsoluteY?: number,
-  tag?: TagDeclarator,
+  angle: number(Angle),
+  length?: number(Length),
+  lengthX?: number(Length),
+  lengthY?: number(Length),
+  endAbsoluteX?: number(Length),
+  endAbsoluteY?: number(Length),
+  tag?: tag,
 ): Sketch
 ```
 
@@ -27,13 +27,13 @@ angledLine(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
-| `angle` | [`number`](/docs/kcl-std/types/std-types-number) | Which angle should the line be drawn at? | Yes |
-| `length` | [`number`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the given angle. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
-| `lengthX` | [`number`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the X axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
-| `lengthY` | [`number`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the Y axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
-| `endAbsoluteX` | [`number`](/docs/kcl-std/types/std-types-number) | Draw the line along the given angle until it reaches this point along the X axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
-| `endAbsoluteY` | [`number`](/docs/kcl-std/types/std-types-number) | Draw the line along the given angle until it reaches this point along the Y axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| `angle` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Which angle should the line be drawn at? | Yes |
+| `length` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the given angle. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
+| `lengthX` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the X axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
+| `lengthY` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Draw the line this distance along the Y axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
+| `endAbsoluteX` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Draw the line along the given angle until it reaches this point along the X axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
+| `endAbsoluteY` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Draw the line along the given angle until it reaches this point along the Y axis. Only one of `length`, `lengthX`, `lengthY`, `endAbsoluteX`, `endAbsoluteY` can be given. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this line. | No |
 
 ### Returns
 
@@ -46,7 +46,10 @@ angledLine(
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> yLine(endAbsolute = 15)
-  |> angledLine(angle = 30, length = 15)
+  |> angledLine(
+    angle = 30,
+    length = 15,
+  )
   |> line(end = [8, -10])
   |> yLine(endAbsolute = 0)
   |> close()

docs/kcl-std/functions/std-sketch-angledLineThatIntersects.md

@@ -10,10 +10,10 @@ Draw an angled line from the current origin, constructing a line segment such th
 ```kcl
 angledLineThatIntersects(
   @sketch: Sketch,
-  angle: number,
-  intersectTag: TagIdentifier,
-  offset?: number,
-  tag?: TagDeclarator,
+  angle: number(Angle),
+  intersectTag: tag,
+  offset?: number(Length),
+  tag?: tag,
 ): Sketch
 ```
 
@@ -24,10 +24,10 @@ angledLineThatIntersects(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
-| `angle` | [`number`](/docs/kcl-std/types/std-types-number) | Which angle should the line be drawn at? | Yes |
-| `intersectTag` | [`TagIdentifier`](/docs/kcl-lang/types#TagIdentifier) | The tag of the line to intersect with | Yes |
-| `offset` | [`number`](/docs/kcl-std/types/std-types-number) | The offset from the intersecting line. Defaults to 0. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| `angle` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Which angle should the line be drawn at? | Yes |
+| `intersectTag` | [`tag`](/docs/kcl-std/types/std-types-tag) | The tag of the line to intersect with. | Yes |
+| `offset` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | The offset from the intersecting line. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this line. | No |
 
 ### Returns
 
@@ -42,7 +42,11 @@ exampleSketch = startSketchOn(XZ)
   |> line(endAbsolute = [5, 10])
   |> line(endAbsolute = [-10, 10], tag = $lineToIntersect)
   |> line(endAbsolute = [0, 20])
-  |> angledLineThatIntersects(angle = 80, intersectTag = lineToIntersect, offset = 10)
+  |> angledLineThatIntersects(
+       angle = 80,
+       intersectTag = lineToIntersect,
+       offset = 10,
+     )
   |> close()
 
 example = extrude(exampleSketch, length = 10)

docs/kcl-std/functions/std-sketch-arc.md

@@ -10,32 +10,37 @@ Draw a curved line segment along an imaginary circle.
 ```kcl
 arc(
   @sketch: Sketch,
-  angleStart?: number,
-  angleEnd?: number,
-  radius?: number,
-  diameter?: number,
+  angleStart?: number(Angle),
+  angleEnd?: number(Angle),
+  radius?: number(Length),
+  diameter?: number(Length),
   interiorAbsolute?: Point2d,
   endAbsolute?: Point2d,
-  tag?: TagDeclarator,
+  tag?: tag,
 ): Sketch
 ```
 
-The arc is constructed such that the current position of the sketch is placed along an imaginary circle of the specified radius, at angleStart degrees. The resulting arc is the segment of the imaginary circle from that origin point to angleEnd, radius away from the center of the imaginary circle.
+The arc is constructed such that the current position of the sketch is
+placed along an imaginary circle of the specified radius, at angleStart
+degrees. The resulting arc is the segment of the imaginary circle from
+that origin point to angleEnd, radius away from the center of the imaginary
+circle.
 
-Unless this makes a lot of sense and feels like what you're looking for to construct your shape, you're likely looking for tangentialArc.
+Unless this makes a lot of sense and feels like what you're looking
+for to construct your shape, you're likely looking for tangentialArc.
 
 ### Arguments
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
-| `angleStart` | [`number`](/docs/kcl-std/types/std-types-number) | Where along the circle should this arc start? | No |
-| `angleEnd` | [`number`](/docs/kcl-std/types/std-types-number) | Where along the circle should this arc end? | No |
-| `radius` | [`number`](/docs/kcl-std/types/std-types-number) | How large should the circle be? Incompatible with `diameter`. | No |
-| `diameter` | [`number`](/docs/kcl-std/types/std-types-number) | How large should the circle be? Incompatible with `radius`. | No |
-| `interiorAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Any point between the arc's start and end? Requires `endAbsolute`. Incompatible with `angleStart` or `angleEnd` | No |
-| `endAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Where should this arc end? Requires `interiorAbsolute`. Incompatible with `angleStart` or `angleEnd` | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| `angleStart` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Where along the circle should this arc start? | No |
+| `angleEnd` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Where along the circle should this arc end? | No |
+| `radius` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | How large should the circle be? Incompatible with `diameter`. | No |
+| `diameter` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | How large should the circle be? Incompatible with `radius`. | No |
+| `interiorAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Any point between the arc's start and end? Requires `endAbsolute`. Incompatible with `angleStart` or `angleEnd`. | No |
+| `endAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Where should this arc end? Requires `interiorAbsolute`. Incompatible with `angleStart` or `angleEnd`. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this arc. | No |
 
 ### Returns
 
@@ -48,7 +53,11 @@ Unless this makes a lot of sense and feels like what you're looking for to const
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> line(end = [10, 0])
-  |> arc(angleStart = 0, angleEnd = 280, radius = 16)
+  |> arc(
+       angleStart = 0,
+       angleEnd = 280,
+       radius = 16
+     )
   |> close()
 example = extrude(exampleSketch, length = 10)
 ```
@@ -58,7 +67,10 @@ example = extrude(exampleSketch, length = 10)
 ```kcl
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
-  |> arc(endAbsolute = [10, 0], interiorAbsolute = [5, 5])
+  |> arc(
+        endAbsolute = [10,0],
+        interiorAbsolute = [5,5]
+     )
   |> close()
 example = extrude(exampleSketch, length = 10)
 ```

docs/kcl-std/functions/std-sketch-circle.md

@@ -1,11 +1,11 @@
 ---
 title: "circle"
 subtitle: "Function in std::sketch"
-excerpt: ""
+excerpt: "Construct a 2-dimensional circle, of the specified radius, centered at the provided (x, y) origin point."
 layout: manual
 ---
 
-
+Construct a 2-dimensional circle, of the specified radius, centered at the provided (x, y) origin point.
 
 ```kcl
 circle(
@@ -17,8 +17,7 @@ circle(
 ): Sketch
 ```
 
-Construct a 2-dimensional circle, of the specified radius, centered at
-the provided (x, y) origin point.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-sketch-extrude.md

@@ -1,11 +1,11 @@
 ---
 title: "extrude"
 subtitle: "Function in std::sketch"
-excerpt: ""
+excerpt: "Extend a 2-dimensional sketch through a third dimension in order to create new 3-dimensional volume, or if extruded into an existing volume, cut into an existing solid."
 layout: manual
 ---
 
-
+Extend a 2-dimensional sketch through a third dimension in order to create new 3-dimensional volume, or if extruded into an existing volume, cut into an existing solid.
 
 ```kcl
 extrude(
@@ -18,9 +18,6 @@ extrude(
 ): [Solid; 1+]
 ```
 
-Extend a 2-dimensional sketch through a third dimension in order to
-create new 3-dimensional volume, or if extruded into an existing volume,cut into an existing solid.
-
 You can provide more than one sketch to extrude, and they will all be
 extruded in the same direction.
 

docs/kcl-std/functions/std-sketch-line.md

@@ -12,7 +12,7 @@ line(
   @sketch: Sketch,
   endAbsolute?: Point2d,
   end?: Point2d,
-  tag?: TagDeclarator,
+  tag?: tag,
 ): Sketch
 ```
 
@@ -25,7 +25,7 @@ line(
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
 | `endAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Which absolute point should this line go to? Incompatible with `end`. | No |
 | `end` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | How far away (along the X and Y axes) should this line go? Incompatible with `endAbsolute`. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this line. | No |
 
 ### Returns
 

docs/kcl-std/functions/std-sketch-loft.md

@@ -19,7 +19,7 @@ loft(
 ): Solid
 ```
 
-The sketches need to closed and on the same plane.
+The sketches need to be closed and on different planes that are parallel.
 
 ### Arguments
 

docs/kcl-std/functions/std-sketch-patternCircular2d.md

@@ -1,11 +1,11 @@
 ---
 title: "patternCircular2d"
 subtitle: "Function in std::sketch"
-excerpt: ""
+excerpt: "Repeat a 2-dimensional sketch some number of times along a partial or complete circle some specified number of times. Each object may additionally be rotated along the circle, ensuring orientation of the solid with respect to the center of the circle is maintained."
 layout: manual
 ---
 
-
+Repeat a 2-dimensional sketch some number of times along a partial or complete circle some specified number of times. Each object may additionally be rotated along the circle, ensuring orientation of the solid with respect to the center of the circle is maintained.
 
 ```kcl
 patternCircular2d(
@@ -18,9 +18,7 @@ patternCircular2d(
 ): [Sketch; 1+]
 ```
 
-Repeat a 2-dimensional sketch some number of times along a partial or
-complete circle some specified number of times. Each object mayadditionally be rotated along the circle, ensuring orientation of the
-solid with respect to the center of the circle is maintained.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-sketch-patternLinear2d.md

@@ -1,11 +1,11 @@
 ---
 title: "patternLinear2d"
 subtitle: "Function in std::sketch"
-excerpt: ""
+excerpt: "Repeat a 2-dimensional sketch along some dimension, with a dynamic amount of distance between each repetition, some specified number of times."
 layout: manual
 ---
 
-
+Repeat a 2-dimensional sketch along some dimension, with a dynamic amount of distance between each repetition, some specified number of times.
 
 ```kcl
 patternLinear2d(
@@ -17,8 +17,7 @@ patternLinear2d(
 ): [Sketch; 1+]
 ```
 
-Repeat a 2-dimensional sketch along some dimension, with a dynamic amount
-of distance between each repetition, some specified number of times.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-sketch-startProfile.md

@@ -9,9 +9,9 @@ Start a new profile at a given point.
 
 ```kcl
 startProfile(
-  @sketchSurface: Plane | Face,
+  @startProfileOn: Plane | Face,
   at: Point2d,
-  tag?: TagDeclarator,
+  tag?: tag,
 ): Sketch
 ```
 
@@ -21,9 +21,9 @@ startProfile(
 
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
-| `sketchSurface` | [`Plane`](/docs/kcl-std/types/std-types-Plane) or [`Face`](/docs/kcl-std/types/std-types-Face) | What to start the profile on | Yes |
+| `startProfileOn` | [`Plane`](/docs/kcl-std/types/std-types-Plane) or [`Face`](/docs/kcl-std/types/std-types-Face) | What to start the profile on. | Yes |
 | `at` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Where to start the profile. An absolute point. | Yes |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Tag this first starting point | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Tag this first starting point. | No |
 
 ### Returns
 

docs/kcl-std/functions/std-sketch-tangentialArc.md

@@ -12,14 +12,18 @@ tangentialArc(
   @sketch: Sketch,
   endAbsolute?: Point2d,
   end?: Point2d,
-  radius?: number,
-  diameter?: number,
-  angle?: number,
-  tag?: TagDeclarator,
+  radius?: number(Length),
+  diameter?: number(Length),
+  angle?: number(Angle),
+  tag?: tag,
 ): Sketch
 ```
 
-When using radius and angle, draw a curved line segment along part of an imaginary circle. The arc is constructed such that the last line segment is placed tangent to the imaginary circle of the specified radius. The resulting arc is the segment of the imaginary circle from that tangent point for 'angle' degrees along the imaginary circle.
+When using radius and angle, draw a curved line segment along part of an
+imaginary circle. The arc is constructed such that the last line segment is
+placed tangent to the imaginary circle of the specified radius. The
+resulting arc is the segment of the imaginary circle from that tangent point
+for 'angle' degrees along the imaginary circle.
 
 ### Arguments
 
@@ -28,10 +32,10 @@ When using radius and angle, draw a curved line segment along part of an imagina
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
 | `endAbsolute` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | Which absolute point should this arc go to? Incompatible with `end`, `radius`, and `offset`. | No |
 | `end` | [`Point2d`](/docs/kcl-std/types/std-types-Point2d) | How far away (along the X and Y axes) should this arc go? Incompatible with `endAbsolute`, `radius`, and `offset`. | No |
-| `radius` | [`number`](/docs/kcl-std/types/std-types-number) | Radius of the imaginary circle. `angle` must be given. Incompatible with `end` and `endAbsolute` and `diameter`. | No |
-| `diameter` | [`number`](/docs/kcl-std/types/std-types-number) | Diameter of the imaginary circle. `angle` must be given. Incompatible with `end` and `endAbsolute` and `radius`. | No |
-| `angle` | [`number`](/docs/kcl-std/types/std-types-number) | Offset of the arc in degrees. `radius` must be given. Incompatible with `end` and `endAbsolute`. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this arc | No |
+| `radius` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Radius of the imaginary circle. `angle` must be given. Incompatible with `end` and `endAbsolute` and `diameter`. | No |
+| `diameter` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Diameter of the imaginary circle. `angle` must be given. Incompatible with `end` and `endAbsolute` and `radius`. | No |
+| `angle` | [`number(Angle)`](/docs/kcl-std/types/std-types-number) | Offset of the arc. `radius` must be given. Incompatible with `end` and `endAbsolute`. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this arc. | No |
 
 ### Returns
 
@@ -43,7 +47,10 @@ When using radius and angle, draw a curved line segment along part of an imagina
 ```kcl
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
-  |> angledLine(angle = 45, length = 10)
+  |> angledLine(
+    angle = 45,
+    length = 10,
+  )
   |> tangentialArc(end = [0, -10])
   |> line(end = [-10, 0])
   |> close()
@@ -56,7 +63,10 @@ example = extrude(exampleSketch, length = 10)
 ```kcl
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
-  |> angledLine(angle = 60, length = 10)
+  |> angledLine(
+    angle = 60,
+    length = 10,
+  )
   |> tangentialArc(endAbsolute = [15, 15])
   |> line(end = [10, -15])
   |> close()
@@ -69,9 +79,15 @@ example = extrude(exampleSketch, length = 10)
 ```kcl
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
-  |> angledLine(angle = 60, length = 10)
+  |> angledLine(
+    angle = 60,
+    length = 10,
+  )
   |> tangentialArc(radius = 10, angle = -120)
-  |> angledLine(angle = -60, length = 10)
+  |> angledLine(
+    angle = -60,
+    length = 10,
+  )
   |> close()
 
 example = extrude(exampleSketch, length = 10)

docs/kcl-std/functions/std-sketch-xLine.md

@@ -10,9 +10,9 @@ Draw a line relative to the current origin to a specified distance away from the
 ```kcl
 xLine(
   @sketch: Sketch,
-  length?: number,
-  endAbsolute?: number,
-  tag?: TagDeclarator,
+  length?: number(Length),
+  endAbsolute?: number(Length),
+  tag?: tag,
 ): Sketch
 ```
 
@@ -23,9 +23,9 @@ xLine(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
-| `length` | [`number`](/docs/kcl-std/types/std-types-number) | How far away along the X axis should this line go? Incompatible with `endAbsolute`. | No |
-| `endAbsolute` | [`number`](/docs/kcl-std/types/std-types-number) | Which absolute X value should this line go to? Incompatible with `length`. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| `length` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | How far away along the X axis should this line go? Incompatible with `endAbsolute`. | No |
+| `endAbsolute` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Which absolute X value should this line go to? Incompatible with `length`. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this line. | No |
 
 ### Returns
 
@@ -38,10 +38,16 @@ xLine(
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> xLine(length = 15)
-  |> angledLine(angle = 80, length = 15)
+  |> angledLine(
+    angle = 80,
+    length = 15,
+  )
   |> line(end = [8, -10])
   |> xLine(length = 10)
-  |> angledLine(angle = 120, length = 30)
+  |> angledLine(
+    angle = 120,
+    length = 30,
+  )
   |> xLine(length = -15)
   |> close()
 

docs/kcl-std/functions/std-sketch-yLine.md

@@ -10,9 +10,9 @@ Draw a line relative to the current origin to a specified distance away from the
 ```kcl
 yLine(
   @sketch: Sketch,
-  length?: number,
-  endAbsolute?: number,
-  tag?: TagDeclarator,
+  length?: number(Length),
+  endAbsolute?: number(Length),
+  tag?: tag,
 ): Sketch
 ```
 
@@ -23,9 +23,9 @@ yLine(
 | Name | Type | Description | Required |
 |----------|------|-------------|----------|
 | `sketch` | [`Sketch`](/docs/kcl-std/types/std-types-Sketch) | Which sketch should this path be added to? | Yes |
-| `length` | [`number`](/docs/kcl-std/types/std-types-number) | How far away along the Y axis should this line go? Incompatible with `endAbsolute`. | No |
-| `endAbsolute` | [`number`](/docs/kcl-std/types/std-types-number) | Which absolute Y value should this line go to? Incompatible with `length`. | No |
-| [`tag`](/docs/kcl-std/types/std-types-tag) | [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator) | Create a new tag which refers to this line | No |
+| `length` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | How far away along the Y axis should this line go? Incompatible with `endAbsolute`. | No |
+| `endAbsolute` | [`number(Length)`](/docs/kcl-std/types/std-types-number) | Which absolute Y value should this line go to? Incompatible with `length`. | No |
+| [`tag`](/docs/kcl-std/types/std-types-tag) | [`tag`](/docs/kcl-std/types/std-types-tag) | Create a new tag which refers to this line. | No |
 
 ### Returns
 
@@ -38,7 +38,10 @@ yLine(
 exampleSketch = startSketchOn(XZ)
   |> startProfile(at = [0, 0])
   |> yLine(length = 15)
-  |> angledLine(angle = 30, length = 15)
+  |> angledLine(
+    angle = 30,
+    length = 15,
+  )
   |> line(end = [8, -10])
   |> yLine(length = -5)
   |> close()

docs/kcl-std/functions/std-solid-intersect.md

@@ -1,11 +1,11 @@
 ---
 title: "intersect"
 subtitle: "Function in std::solid"
-excerpt: ""
+excerpt: "Intersect returns the shared volume between multiple solids, preserving only overlapping regions."
 layout: manual
 ---
 
-
+Intersect returns the shared volume between multiple solids, preserving only overlapping regions.
 
 ```kcl
 intersect(
@@ -14,8 +14,6 @@ intersect(
 ): [Solid; 1+]
 ```
 
-Intersect returns the shared volume between multiple solids, preserving only
-overlapping regions.
 Intersect computes the geometric intersection of multiple solid bodies,
 returning a new solid representing the volume that is common to all input
 solids. This operation is useful for determining shared material regions,

docs/kcl-std/functions/std-solid-patternCircular3d.md

@@ -1,11 +1,11 @@
 ---
 title: "patternCircular3d"
 subtitle: "Function in std::solid"
-excerpt: ""
+excerpt: "Repeat a 3-dimensional solid some number of times along a partial or complete circle some specified number of times. Each object may additionally be rotated along the circle, ensuring orientation of the solid with respect to the center of the circle is maintained."
 layout: manual
 ---
 
-
+Repeat a 3-dimensional solid some number of times along a partial or complete circle some specified number of times. Each object may additionally be rotated along the circle, ensuring orientation of the solid with respect to the center of the circle is maintained.
 
 ```kcl
 patternCircular3d(
@@ -19,9 +19,7 @@ patternCircular3d(
 ): [Solid; 1+]
 ```
 
-Repeat a 3-dimensional solid some number of times along a partial or
-complete circle some specified number of times. Each object mayadditionally be rotated along the circle, ensuring orientation of the
-solid with respect to the center of the circle is maintained.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-solid-patternLinear3d.md

@@ -1,11 +1,11 @@
 ---
 title: "patternLinear3d"
 subtitle: "Function in std::solid"
-excerpt: ""
+excerpt: "Repeat a 3-dimensional solid along a linear path, with a dynamic amount of distance between each repetition, some specified number of times."
 layout: manual
 ---
 
-
+Repeat a 3-dimensional solid along a linear path, with a dynamic amount of distance between each repetition, some specified number of times.
 
 ```kcl
 patternLinear3d(
@@ -17,8 +17,7 @@ patternLinear3d(
 ): [Solid; 1+]
 ```
 
-Repeat a 3-dimensional solid along a linear path, with a dynamic amount
-of distance between each repetition, some specified number of times.
+
 
 ### Arguments
 

docs/kcl-std/functions/std-solid-shell.md

@@ -1,11 +1,11 @@
 ---
 title: "shell"
 subtitle: "Function in std::solid"
-excerpt: ""
+excerpt: "Remove volume from a 3-dimensional shape such that a wall of the provided thickness remains, taking volume starting at the provided face, leaving it open in that direction."
 layout: manual
 ---
 
-
+Remove volume from a 3-dimensional shape such that a wall of the provided thickness remains, taking volume starting at the provided face, leaving it open in that direction.
 
 ```kcl
 shell(
@@ -15,8 +15,7 @@ shell(
 ): [Solid]
 ```
 
-Remove volume from a 3-dimensional shape such that a wall of the
-provided thickness remains, taking volume starting at the providedface, leaving it open in that direction.
+
 
 ### Arguments
 

docs/kcl-std/index.md

@@ -47,30 +47,30 @@ layout: manual
   * [`sqrt`](/docs/kcl-std/functions/std-math-sqrt)
   * [`tan`](/docs/kcl-std/functions/std-math-tan)
 * [**std::sketch**](/docs/kcl-std/modules/std-sketch)
-  * [`angledLine`](/docs/kcl-std/angledLine)
-  * [`angledLineThatIntersects`](/docs/kcl-std/angledLineThatIntersects)
-  * [`arc`](/docs/kcl-std/arc)
-  * [`bezierCurve`](/docs/kcl-std/bezierCurve)
+  * [`angledLine`](/docs/kcl-std/functions/std-sketch-angledLine)
+  * [`angledLineThatIntersects`](/docs/kcl-std/functions/std-sketch-angledLineThatIntersects)
+  * [`arc`](/docs/kcl-std/functions/std-sketch-arc)
+  * [`bezierCurve`](/docs/kcl-std/functions/std-sketch-bezierCurve)
   * [`circle`](/docs/kcl-std/functions/std-sketch-circle)
   * [`circleThreePoint`](/docs/kcl-std/functions/std-sketch-circleThreePoint)
-  * [`close`](/docs/kcl-std/close)
+  * [`close`](/docs/kcl-std/functions/std-sketch-close)
   * [`extrude`](/docs/kcl-std/functions/std-sketch-extrude)
   * [`getCommonEdge`](/docs/kcl-std/functions/std-sketch-getCommonEdge)
   * [`getNextAdjacentEdge`](/docs/kcl-std/functions/std-sketch-getNextAdjacentEdge)
   * [`getOppositeEdge`](/docs/kcl-std/functions/std-sketch-getOppositeEdge)
   * [`getPreviousAdjacentEdge`](/docs/kcl-std/functions/std-sketch-getPreviousAdjacentEdge)
-  * [`involuteCircular`](/docs/kcl-std/involuteCircular)
+  * [`involuteCircular`](/docs/kcl-std/functions/std-sketch-involuteCircular)
   * [`lastSegX`](/docs/kcl-std/functions/std-sketch-lastSegX)
   * [`lastSegY`](/docs/kcl-std/functions/std-sketch-lastSegY)
-  * [`line`](/docs/kcl-std/line)
+  * [`line`](/docs/kcl-std/functions/std-sketch-line)
   * [`loft`](/docs/kcl-std/functions/std-sketch-loft)
   * [`patternCircular2d`](/docs/kcl-std/functions/std-sketch-patternCircular2d)
   * [`patternLinear2d`](/docs/kcl-std/functions/std-sketch-patternLinear2d)
   * [`patternTransform2d`](/docs/kcl-std/functions/std-sketch-patternTransform2d)
   * [`polygon`](/docs/kcl-std/functions/std-sketch-polygon)
-  * [`profileStart`](/docs/kcl-std/profileStart)
-  * [`profileStartX`](/docs/kcl-std/profileStartX)
-  * [`profileStartY`](/docs/kcl-std/profileStartY)
+  * [`profileStart`](/docs/kcl-std/functions/std-sketch-profileStart)
+  * [`profileStartX`](/docs/kcl-std/functions/std-sketch-profileStartX)
+  * [`profileStartY`](/docs/kcl-std/functions/std-sketch-profileStartY)
   * [`revolve`](/docs/kcl-std/functions/std-sketch-revolve)
   * [`segAng`](/docs/kcl-std/functions/std-sketch-segAng)
   * [`segEnd`](/docs/kcl-std/functions/std-sketch-segEnd)
@@ -80,14 +80,14 @@ layout: manual
   * [`segStart`](/docs/kcl-std/functions/std-sketch-segStart)
   * [`segStartX`](/docs/kcl-std/functions/std-sketch-segStartX)
   * [`segStartY`](/docs/kcl-std/functions/std-sketch-segStartY)
-  * [`startProfile`](/docs/kcl-std/startProfile)
-  * [`startSketchOn`](/docs/kcl-std/startSketchOn)
-  * [`subtract2d`](/docs/kcl-std/subtract2d)
+  * [`startProfile`](/docs/kcl-std/functions/std-sketch-startProfile)
+  * [`startSketchOn`](/docs/kcl-std/functions/std-sketch-startSketchOn)
+  * [`subtract2d`](/docs/kcl-std/functions/std-sketch-subtract2d)
   * [`sweep`](/docs/kcl-std/functions/std-sketch-sweep)
   * [`tangentToEnd`](/docs/kcl-std/functions/std-sketch-tangentToEnd)
-  * [`tangentialArc`](/docs/kcl-std/tangentialArc)
-  * [`xLine`](/docs/kcl-std/xLine)
-  * [`yLine`](/docs/kcl-std/yLine)
+  * [`tangentialArc`](/docs/kcl-std/functions/std-sketch-tangentialArc)
+  * [`xLine`](/docs/kcl-std/functions/std-sketch-xLine)
+  * [`yLine`](/docs/kcl-std/functions/std-sketch-yLine)
 * [**std::solid**](/docs/kcl-std/modules/std-solid)
   * [`appearance`](/docs/kcl-std/functions/std-solid-appearance)
   * [`chamfer`](/docs/kcl-std/functions/std-solid-chamfer)
@@ -144,11 +144,7 @@ layout: manual
 See also the [types overview](/docs/kcl-lang/types)
 
 * [**Primitive types**](/docs/kcl-lang/types)
-  * [`End`](/docs/kcl-lang/types#End)
   * [`ImportedGeometry`](/docs/kcl-std/types/std-types-ImportedGeometry)
-  * [`Start`](/docs/kcl-lang/types#Start)
-  * [`TagDeclarator`](/docs/kcl-lang/types#TagDeclarator)
-  * [`TagIdentifier`](/docs/kcl-lang/types#TagIdentifier)
   * [`any`](/docs/kcl-std/types/std-types-any)
   * [`bool`](/docs/kcl-std/types/std-types-bool)
   * [`fn`](/docs/kcl-std/types/std-types-fn)

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

@@ -12,30 +12,30 @@ This module contains functions for creating and manipulating sketches, and makin
 
 ## Functions and constants
 
-* [`angledLine`](/docs/kcl-std/angledLine)
-* [`angledLineThatIntersects`](/docs/kcl-std/angledLineThatIntersects)
-* [`arc`](/docs/kcl-std/arc)
-* [`bezierCurve`](/docs/kcl-std/bezierCurve)
+* [`angledLine`](/docs/kcl-std/functions/std-sketch-angledLine)
+* [`angledLineThatIntersects`](/docs/kcl-std/functions/std-sketch-angledLineThatIntersects)
+* [`arc`](/docs/kcl-std/functions/std-sketch-arc)
+* [`bezierCurve`](/docs/kcl-std/functions/std-sketch-bezierCurve)
 * [`circle`](/docs/kcl-std/functions/std-sketch-circle)
 * [`circleThreePoint`](/docs/kcl-std/functions/std-sketch-circleThreePoint)
-* [`close`](/docs/kcl-std/close)
+* [`close`](/docs/kcl-std/functions/std-sketch-close)
 * [`extrude`](/docs/kcl-std/functions/std-sketch-extrude)
 * [`getCommonEdge`](/docs/kcl-std/functions/std-sketch-getCommonEdge)
 * [`getNextAdjacentEdge`](/docs/kcl-std/functions/std-sketch-getNextAdjacentEdge)
 * [`getOppositeEdge`](/docs/kcl-std/functions/std-sketch-getOppositeEdge)
 * [`getPreviousAdjacentEdge`](/docs/kcl-std/functions/std-sketch-getPreviousAdjacentEdge)
-* [`involuteCircular`](/docs/kcl-std/involuteCircular)
+* [`involuteCircular`](/docs/kcl-std/functions/std-sketch-involuteCircular)
 * [`lastSegX`](/docs/kcl-std/functions/std-sketch-lastSegX)
 * [`lastSegY`](/docs/kcl-std/functions/std-sketch-lastSegY)
-* [`line`](/docs/kcl-std/line)
+* [`line`](/docs/kcl-std/functions/std-sketch-line)
 * [`loft`](/docs/kcl-std/functions/std-sketch-loft)
 * [`patternCircular2d`](/docs/kcl-std/functions/std-sketch-patternCircular2d)
 * [`patternLinear2d`](/docs/kcl-std/functions/std-sketch-patternLinear2d)
 * [`patternTransform2d`](/docs/kcl-std/functions/std-sketch-patternTransform2d)
 * [`polygon`](/docs/kcl-std/functions/std-sketch-polygon)
-* [`profileStart`](/docs/kcl-std/profileStart)
-* [`profileStartX`](/docs/kcl-std/profileStartX)
-* [`profileStartY`](/docs/kcl-std/profileStartY)
+* [`profileStart`](/docs/kcl-std/functions/std-sketch-profileStart)
+* [`profileStartX`](/docs/kcl-std/functions/std-sketch-profileStartX)
+* [`profileStartY`](/docs/kcl-std/functions/std-sketch-profileStartY)
 * [`revolve`](/docs/kcl-std/functions/std-sketch-revolve)
 * [`segAng`](/docs/kcl-std/functions/std-sketch-segAng)
 * [`segEnd`](/docs/kcl-std/functions/std-sketch-segEnd)
@@ -45,12 +45,12 @@ This module contains functions for creating and manipulating sketches, and makin
 * [`segStart`](/docs/kcl-std/functions/std-sketch-segStart)
 * [`segStartX`](/docs/kcl-std/functions/std-sketch-segStartX)
 * [`segStartY`](/docs/kcl-std/functions/std-sketch-segStartY)
-* [`startProfile`](/docs/kcl-std/startProfile)
-* [`startSketchOn`](/docs/kcl-std/startSketchOn)
-* [`subtract2d`](/docs/kcl-std/subtract2d)
+* [`startProfile`](/docs/kcl-std/functions/std-sketch-startProfile)
+* [`startSketchOn`](/docs/kcl-std/functions/std-sketch-startSketchOn)
+* [`subtract2d`](/docs/kcl-std/functions/std-sketch-subtract2d)
 * [`sweep`](/docs/kcl-std/functions/std-sketch-sweep)
 * [`tangentToEnd`](/docs/kcl-std/functions/std-sketch-tangentToEnd)
-* [`tangentialArc`](/docs/kcl-std/tangentialArc)
-* [`xLine`](/docs/kcl-std/xLine)
-* [`yLine`](/docs/kcl-std/yLine)
+* [`tangentialArc`](/docs/kcl-std/functions/std-sketch-tangentialArc)
+* [`xLine`](/docs/kcl-std/functions/std-sketch-xLine)
+* [`yLine`](/docs/kcl-std/functions/std-sketch-yLine)
 

docs/kcl-std/types/std-types-any.md

@@ -1,14 +1,13 @@
 ---
 title: "any"
 subtitle: "Type in std::types"
-excerpt: ""
+excerpt: "The [`any`](/docs/kcl-std/types/std-types-any) type is the type of all possible values in KCL. I.e., if a function accepts an argument with type [`any`](/docs/kcl-std/types/std-types-any), then it can accept any value."
 layout: manual
 ---
 
+The [`any`](/docs/kcl-std/types/std-types-any) type is the type of all possible values in KCL. I.e., if a function accepts an argument with type [`any`](/docs/kcl-std/types/std-types-any), then it can accept any value.
 
 
-The [`any`](/docs/kcl-std/types/std-types-any) type is the type of all possible values in KCL. I.e., if a function accepts an argument
-with type [`any`](/docs/kcl-std/types/std-types-any), then it can accept any value.
 
 
 ### Examples

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

@@ -534,7 +534,7 @@ profile001 = startProfile(sketch001, at = [-484.34, 484.95])
   |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
   |> close()
 `
-        const targetURL = `?create-file&name=test&units=mm&code=${encodeURIComponent(btoa(code))}&ask-open-desktop`
+        const targetURL = `?create-file=true&name=test&units=mm&code=${encodeURIComponent(btoa(code))}&ask-open-desktop=true`
         await page.goto(page.url() + targetURL)
         expect(page.url()).toContain(targetURL)
       })

e2e/playwright/editor-tests.spec.ts

@@ -964,8 +964,6 @@ a1 = startSketchOn(offsetPlane(XY, offset = 10))
       await page.waitForTimeout(100)
       await page.keyboard.press('Enter') // accepting the auto complete, not a new line
 
-      await page.keyboard.press('Tab')
-      await page.waitForTimeout(100)
       await page.keyboard.press('Tab')
       await page.waitForTimeout(100)
       await page.keyboard.type('12')
@@ -984,8 +982,6 @@ a1 = startSketchOn(offsetPlane(XY, offset = 10))
       await page.keyboard.press('ArrowDown')
       await page.keyboard.press('Enter')
       // finish line with comment
-      await page.keyboard.press('Tab')
-      await page.waitForTimeout(100)
       await page.keyboard.type('5')
       await page.waitForTimeout(100)
       await page.keyboard.press('Tab')
@@ -1001,8 +997,8 @@ a1 = startSketchOn(offsetPlane(XY, offset = 10))
       await expect(page.locator('.cm-content')).toHaveText(
         `@settings(defaultLengthUnit = in)
 sketch001 = startSketchOn(XZ)
-        |> startProfile(%, at = [0, 12])
-        |> xLine(%, length = 5) // lin`.replaceAll('\n', '')
+    |> startProfile(at = [0, 12])
+    |> xLine(length = 5) // lin`.replaceAll('\n', '')
       )
 
       // expect there to be no KCL errors
@@ -1040,8 +1036,6 @@ sketch001 = startSketchOn(XZ)
       await page.waitForTimeout(100)
       await page.keyboard.press('Tab') // accepting the auto complete, not a new line
 
-      await page.keyboard.press('Tab')
-      await page.waitForTimeout(100)
       await page.keyboard.press('Tab')
       await page.keyboard.type('12')
       await page.waitForTimeout(100)
@@ -1057,7 +1051,6 @@ sketch001 = startSketchOn(XZ)
       await page.waitForTimeout(100)
       // press arrow down then tab to accept xLine
       await page.keyboard.press('ArrowDown')
-      await page.keyboard.press('Tab')
       // finish line with comment
       await page.keyboard.press('Tab')
       await page.waitForTimeout(100)
@@ -1076,8 +1069,8 @@ sketch001 = startSketchOn(XZ)
       await expect(page.locator('.cm-content')).toHaveText(
         `@settings(defaultLengthUnit = in)
 sketch001 = startSketchOn(XZ)
-        |> startProfile(%, at = [0, 12])
-        |> xLine(%, length = 5) // lin`.replaceAll('\n', '')
+    |> startProfile(at = [0, 12])
+    |> xLine(length = 5) // lin`.replaceAll('\n', '')
       )
     })
   })

e2e/playwright/projects.spec.ts

@@ -169,7 +169,8 @@ test(
 
       // error text on hover
       await page.hover('.cm-lint-marker-error')
-      const crypticErrorText = `The arg tag was given, but it was the wrong type`
+      const crypticErrorText =
+        'tag requires a value with type `tag`, but found string'
       await expect(page.getByText(crypticErrorText).first()).toBeVisible()
 
       // black pixel means the scene has been cleared.
@@ -367,7 +368,8 @@ test(
 
       // error text on hover
       await page.hover('.cm-lint-marker-error')
-      const crypticErrorText = `The arg tag was given, but it was the wrong type`
+      const crypticErrorText =
+        'tag requires a value with type `tag`, but found string'
       await expect(page.getByText(crypticErrorText).first()).toBeVisible()
 
       // black pixel means the scene has been cleared.
@@ -405,7 +407,8 @@ test(
 
     // error text on hover
     await page.hover('.cm-lint-marker-error')
-    const crypticErrorText = `The arg tag was given, but it was the wrong type`
+    const crypticErrorText =
+      'tag requires a value with type `tag`, but found string'
     await expect(page.getByText(crypticErrorText).first()).toBeVisible()
   }
 )

e2e/playwright/sketch-tests.spec.ts

@@ -749,7 +749,7 @@ sketch001 = startSketchOn(XZ)
     // expect the code to have changed
     await editor.expectEditor.toContain(
       `sketch001 = startSketchOn(XZ)
-  |> startProfile(at = [8.41, -9.97]) 
+  |> startProfile(at = [8.41, -9.97])
   |> line(end = [12.73, -0.09])
   |> line(end = [1.99, 2.06])
   |> tangentialArc(endAbsolute = [24.95, -5.38])
@@ -2329,16 +2329,18 @@ profile004 = circleThreePoint(sketch001, p1 = [13.44, -6.8], p2 = [13.39, -2.07]
       await page.mouse.down()
       await rectDragTo()
       await page.mouse.up()
+      await page.waitForTimeout(200)
       await editor.expectEditor.toContain(
         `angledLine(angle = -7, length = 10.27, tag = $rectangleSegmentA001)`
       )
     })
 
-    await test.step('edit existing circl', async () => {
+    await test.step('edit existing circle', async () => {
       await circleEdge()
       await page.mouse.down()
       await dragCircleTo()
       await page.mouse.up()
+      await page.waitForTimeout(200)
       await editor.expectEditor.toContain(
         `profile003 = circle(sketch001, center = [6.92, -4.2], radius = 4.81)`
       )
@@ -2349,6 +2351,7 @@ profile004 = circleThreePoint(sketch001, p1 = [13.44, -6.8], p2 = [13.39, -2.07]
       await page.mouse.down()
       await circ3PEnd()
       await page.mouse.up()
+      await page.waitForTimeout(200)
       await editor.expectEditor.toContain(
         `profile004 = circleThreePoint(
   sketch001,
@@ -2362,7 +2365,7 @@ profile004 = circleThreePoint(sketch001, p1 = [13.44, -6.8], p2 = [13.39, -2.07]
 
     await test.step('add new profile', async () => {
       await toolbar.rectangleBtn.click()
-      await page.waitForTimeout(100)
+      await page.waitForTimeout(200)
       await rectStart()
       await editor.expectEditor.toContain(
         `profile005 = startProfile(sketch001, at = [15.68, -3.84])`

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

@@ -63,7 +63,7 @@ test.describe('Test network related behaviors', () => {
       })
 
       // Expect the network to be down
-      await expect(networkToggle).toContainText('Problem')
+      await expect(networkToggle).toContainText('Network health (Offline)')
 
       // Click the network widget
       await networkWidget.click()
@@ -160,7 +160,8 @@ test.describe('Test network related behaviors', () => {
 
       // Expect the network to be down
       await networkToggle.hover()
-      await expect(networkToggle).toContainText('Problem')
+
+      await expect(networkToggle).toContainText('Network health (Offline)')
 
       // Ensure we are not in sketch mode
       await expect(

e2e/playwright/test-utils.ts

@@ -364,11 +364,6 @@ export async function getUtils(page: Page, test_?: typeof test) {
     )
   }
 
-  // Chrome devtools protocol session only works in Chromium
-  const browserType = page.context().browser()?.browserType().name()
-  const cdpSession =
-    browserType !== 'chromium' ? null : await page.context().newCDPSession(page)
-
   const util = {
     waitForAuthSkipAppStart: () => waitForAuthAndLsp(page),
     waitForPageLoad: () => waitForPageLoad(page),
@@ -489,15 +484,9 @@ export async function getUtils(page: Page, test_?: typeof test) {
     emulateNetworkConditions: async (
       networkOptions: Protocol.Network.emulateNetworkConditionsParameters
     ) => {
-      if (cdpSession === null) {
-        // Use a fail safe if we can't simulate disconnect (on Safari)
-        return page.evaluate('window.engineCommandManager.tearDown()')
-      }
-
-      return cdpSession?.send(
-        'Network.emulateNetworkConditions',
-        networkOptions
-      )
+      return networkOptions.offline
+        ? page.evaluate('window.engineCommandManager.offline()')
+        : page.evaluate('window.engineCommandManager.online()')
     },
 
     toNormalizedCode(text: string) {

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

@@ -3,187 +3,250 @@ import { uuidv4 } from '@src/lib/utils'
 
 import { getUtils } from '@e2e/playwright/test-utils'
 import { expect, test } from '@e2e/playwright/zoo-test'
+import type { Page } from '@playwright/test'
+import type { SceneFixture } from '@e2e/playwright/fixtures/sceneFixture'
 
 test.describe('Testing Camera Movement', () => {
-  test('Can move camera reliably', async ({
+  /**
+   * hack that we're implemented our own retry instead of using retries built into playwright.
+   * however each of these camera drags can be flaky, because of udp
+   * and so putting them together means only one needs to fail to make this test extra flaky.
+   * this way we can retry within the test
+   * We could break them out into separate tests, but the longest past of the test is waiting
+   * for the stream to start, so it can be good to bundle related things together.
+   */
+  const bakeInRetries = async ({
+    mouseActions,
+    afterPosition,
+    beforePosition,
+    retryCount = 0,
     page,
-    context,
-    homePage,
     scene,
+  }: {
+    mouseActions: () => Promise<void>
+    beforePosition: [number, number, number]
+    afterPosition: [number, number, number]
+    retryCount?: number
+    page: Page
+    scene: SceneFixture
   }) => {
+    const acceptableCamError = 5
     const u = await getUtils(page)
-    await page.setBodyDimensions({ width: 1200, height: 500 })
 
-    await homePage.goToModelingScene()
-    await scene.connectionEstablished()
+    await test.step('Set up initial camera position', async () =>
+      await scene.moveCameraTo({
+        x: beforePosition[0],
+        y: beforePosition[1],
+        z: beforePosition[2],
+      }))
 
-    await u.openAndClearDebugPanel()
-    await u.closeKclCodePanel()
-
-    const camPos: [number, number, number] = [0, 85, 85]
-    const bakeInRetries = async (
-      mouseActions: any,
-      xyz: [number, number, number],
-      cnt = 0
-    ) => {
-      // hack that we're implemented our own retry instead of using retries built into playwright.
-      // however each of these camera drags can be flaky, because of udp
-      // and so putting them together means only one needs to fail to make this test extra flaky.
-      // this way we can retry within the test
-      // We could break them out into separate tests, but the longest past of the test is waiting
-      // for the stream to start, so it can be good to bundle related things together.
-
-      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: camPos[0], y: camPos[1], z: camPos[2] },
-          up: { x: 0, y: 0, z: 1 },
-        },
-      }
-      const updateCamCommand: EngineCommand = {
-        type: 'modeling_cmd_req',
-        cmd_id: uuidv4(),
-        cmd: {
-          type: 'default_camera_get_settings',
-        },
-      }
-      await u.sendCustomCmd(camCommand)
-      await page.waitForTimeout(100)
-      await u.sendCustomCmd(updateCamCommand)
-      await page.waitForTimeout(100)
-
-      // rotate
-      await u.closeDebugPanel()
-      await page.getByRole('button', { name: 'Start Sketch' }).click()
-      await page.waitForTimeout(100)
-      // const yo = page.getByTestId('cam-x-position').inputValue()
-
-      await u.doAndWaitForImageDiff(async () => {
+    await test.step('Do actions and watch for changes', async () =>
+      u.doAndWaitForImageDiff(async () => {
         await mouseActions()
 
         await u.openAndClearDebugPanel()
-
         await u.closeDebugPanel()
         await page.waitForTimeout(100)
-      }, 300)
+      }, 300))
+
+    await u.openAndClearDebugPanel()
+    await expect(page.getByTestId('cam-x-position')).toBeAttached()
+
+    const vals = await Promise.all([
+      page.getByTestId('cam-x-position').inputValue(),
+      page.getByTestId('cam-y-position').inputValue(),
+      page.getByTestId('cam-z-position').inputValue(),
+    ])
+    const errors = vals.map((v, i) => Math.abs(Number(v) - afterPosition[i]))
+    let shouldRetry = false
+
+    if (errors.some((e) => e > acceptableCamError)) {
+      if (retryCount > 2) {
+        console.log('xVal', vals[0], 'xError', errors[0])
+        console.log('yVal', vals[1], 'yError', errors[1])
+        console.log('zVal', vals[2], 'zError', errors[2])
+
+        throw new Error('Camera position not as expected', {
+          cause: {
+            vals,
+            errors,
+          },
+        })
+      }
+      shouldRetry = true
+    }
+    if (shouldRetry) {
+      await bakeInRetries({
+        mouseActions,
+        afterPosition: afterPosition,
+        beforePosition: beforePosition,
+        retryCount: retryCount + 1,
+        page,
+        scene,
+      })
+    }
+  }
+
+  test(
+    'Can pan and zoom camera reliably',
+    {
+      tag: '@web',
+    },
+    async ({ page, homePage, scene, cmdBar }) => {
+      const u = await getUtils(page)
+      const camInitialPosition: [number, number, number] = [0, 85, 85]
+
+      await homePage.goToModelingScene()
+      await scene.settled(cmdBar)
 
       await u.openAndClearDebugPanel()
-      await page.getByTestId('cam-x-position').isVisible()
+      await u.closeKclCodePanel()
 
-      const vals = await Promise.all([
-        page.getByTestId('cam-x-position').inputValue(),
-        page.getByTestId('cam-y-position').inputValue(),
-        page.getByTestId('cam-z-position').inputValue(),
-      ])
-      const xError = Math.abs(Number(vals[0]) + xyz[0])
-      const yError = Math.abs(Number(vals[1]) + xyz[1])
-      const zError = Math.abs(Number(vals[2]) + xyz[2])
+      await test.step('Pan', async () => {
+        await bakeInRetries({
+          mouseActions: async () => {
+            await page.keyboard.down('Shift')
+            await page.mouse.move(600, 200)
+            await page.mouse.down({ button: 'right' })
+            // Gotcha: remove steps:2 from this 700,200 mouse move. This bricked the test on local host engine.
+            await page.mouse.move(700, 200)
+            await page.mouse.up({ button: 'right' })
+            await page.keyboard.up('Shift')
+            await page.waitForTimeout(200)
+          },
+          afterPosition: [19, 85, 85],
+          beforePosition: camInitialPosition,
+          page,
+          scene,
+        })
+      })
 
-      let shouldRetry = false
+      await test.step('Zoom with click and drag', async () => {
+        await bakeInRetries({
+          mouseActions: async () => {
+            await page.keyboard.down('Control')
+            await page.mouse.move(700, 400)
+            await page.mouse.down({ button: 'right' })
+            await page.mouse.move(700, 300)
+            await page.mouse.up({ button: 'right' })
+            await page.keyboard.up('Control')
+          },
+          afterPosition: [0, 118, 118],
+          beforePosition: camInitialPosition,
+          page,
+          scene,
+        })
+      })
 
-      if (xError > 5 || yError > 5 || zError > 5) {
-        if (cnt > 2) {
-          console.log('xVal', vals[0], 'xError', xError)
-          console.log('yVal', vals[1], 'yError', yError)
-          console.log('zVal', vals[2], 'zError', zError)
-
-          throw new Error('Camera position not as expected')
+      await test.step('Zoom with scrollwheel', async () => {
+        const refreshCamValuesCmd: EngineCommand = {
+          type: 'modeling_cmd_req',
+          cmd_id: uuidv4(),
+          cmd: {
+            type: 'default_camera_get_settings',
+          },
         }
-        shouldRetry = true
-      }
-      await page.getByRole('button', { name: 'Exit Sketch' }).click()
-      await page.waitForTimeout(100)
-      if (shouldRetry) await bakeInRetries(mouseActions, xyz, cnt + 1)
+        await bakeInRetries({
+          mouseActions: async () => {
+            await page.mouse.move(700, 400)
+            await page.mouse.wheel(0, -150)
+
+            // Scroll zooming doesn't update the debug pane's cam position values,
+            // so we have to force a refresh.
+            await u.openAndClearDebugPanel()
+            await u.sendCustomCmd(refreshCamValuesCmd)
+            await u.waitForCmdReceive('default_camera_get_settings')
+            await u.closeDebugPanel()
+          },
+          afterPosition: [0, 42.5, 42.5],
+          beforePosition: camInitialPosition,
+          page,
+          scene,
+        })
+      })
     }
-    await bakeInRetries(async () => {
-      await page.mouse.move(700, 200)
-      await page.mouse.down({ button: 'right' })
-      await page.waitForTimeout(100)
+  )
 
-      const appLogoBBox = await page.getByTestId('app-logo').boundingBox()
-      expect(appLogoBBox).not.toBeNull()
-      if (!appLogoBBox) throw new Error('app logo not found')
-      await page.mouse.move(
-        appLogoBBox.x + appLogoBBox.width / 2,
-        appLogoBBox.y + appLogoBBox.height / 2
-      )
-      await page.waitForTimeout(100)
-      await page.mouse.move(600, 303)
-      await page.waitForTimeout(100)
-      await page.mouse.up({ button: 'right' })
-    }, [4, -10.5, -120])
+  test(
+    'Can orbit camera reliably',
+    {
+      tag: '@web',
+    },
+    async ({ page, homePage, scene, cmdBar }) => {
+      const u = await getUtils(page)
+      const initialCamPosition: [number, number, number] = [0, 85, 85]
 
-    await bakeInRetries(async () => {
-      await page.keyboard.down('Shift')
-      await page.mouse.move(600, 200)
-      await page.mouse.down({ button: 'right' })
-      // Gotcha: remove steps:2 from this 700,200 mouse move. This bricked the test on local host engine.
-      await page.mouse.move(700, 200)
-      await page.mouse.up({ button: 'right' })
-      await page.keyboard.up('Shift')
-    }, [-19, -85, -85])
+      await homePage.goToModelingScene()
+      // this turns on the debug pane setting as well
+      await scene.settled(cmdBar)
 
-    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: camPos[0], y: camPos[1], z: camPos[2] },
-        up: { x: 0, y: 0, z: 1 },
-      },
+      await u.openAndClearDebugPanel()
+      await u.closeKclCodePanel()
+
+      await test.step('Test orbit with spherical mode', async () => {
+        await bakeInRetries({
+          mouseActions: async () => {
+            await page.mouse.move(700, 200)
+            await page.mouse.down({ button: 'right' })
+            await page.waitForTimeout(100)
+
+            const appLogoBBox = await page.getByTestId('app-logo').boundingBox()
+            expect(appLogoBBox).not.toBeNull()
+            if (!appLogoBBox) throw new Error('app logo not found')
+            await page.mouse.move(
+              appLogoBBox.x + appLogoBBox.width / 2,
+              appLogoBBox.y + appLogoBBox.height / 2
+            )
+            await page.waitForTimeout(100)
+            await page.mouse.move(600, 303)
+            await page.waitForTimeout(100)
+            await page.mouse.up({ button: 'right' })
+          },
+          afterPosition: [-4, 10.5, 120],
+          beforePosition: initialCamPosition,
+          page,
+          scene,
+        })
+      })
+
+      await test.step('Test orbit with trackball mode', async () => {
+        await test.step('Set orbitMode to trackball', async () => {
+          await cmdBar.openCmdBar()
+          await cmdBar.selectOption({ name: 'camera orbit' }).click()
+          await cmdBar.selectOption({ name: 'trackball' }).click()
+          await expect(
+            page.getByText(`camera orbit to "trackball"`)
+          ).toBeVisible()
+        })
+
+        await bakeInRetries({
+          mouseActions: async () => {
+            await page.mouse.move(700, 200)
+            await page.mouse.down({ button: 'right' })
+            await page.waitForTimeout(100)
+
+            const appLogoBBox = await page.getByTestId('app-logo').boundingBox()
+            expect(appLogoBBox).not.toBeNull()
+            if (!appLogoBBox) {
+              throw new Error('app logo not found')
+            }
+            await page.mouse.move(
+              appLogoBBox.x + appLogoBBox.width / 2,
+              appLogoBBox.y + appLogoBBox.height / 2
+            )
+            await page.waitForTimeout(100)
+            await page.mouse.move(600, 303)
+            await page.waitForTimeout(100)
+            await page.mouse.up({ button: 'right' })
+          },
+          afterPosition: [18.06, -42.79, 110.87],
+          beforePosition: initialCamPosition,
+          page,
+          scene,
+        })
+      })
     }
-    const updateCamCommand: EngineCommand = {
-      type: 'modeling_cmd_req',
-      cmd_id: uuidv4(),
-      cmd: {
-        type: 'default_camera_get_settings',
-      },
-    }
-    await u.sendCustomCmd(camCommand)
-    await page.waitForTimeout(100)
-    await u.sendCustomCmd(updateCamCommand)
-    await page.waitForTimeout(100)
-
-    await u.clearCommandLogs()
-    await u.closeDebugPanel()
-
-    await page.getByRole('button', { name: 'Start Sketch' }).click()
-    await page.waitForTimeout(200)
-
-    // zoom
-    await u.doAndWaitForImageDiff(async () => {
-      await page.keyboard.down('Control')
-      await page.mouse.move(700, 400)
-      await page.mouse.down({ button: 'right' })
-      await page.mouse.move(700, 300)
-      await page.mouse.up({ button: 'right' })
-      await page.keyboard.up('Control')
-
-      await u.openDebugPanel()
-      await page.waitForTimeout(300)
-      await u.clearCommandLogs()
-
-      await u.closeDebugPanel()
-    }, 300)
-
-    // zoom with scroll
-    await u.openAndClearDebugPanel()
-    // TODO, it appears we don't get the cam setting back from the engine when the interaction is zoom into `backInRetries` once the information is sent back on zoom
-    // await expect(Math.abs(Number(await page.getByTestId('cam-x-position').inputValue()) + 12)).toBeLessThan(1.5)
-    // await expect(Math.abs(Number(await page.getByTestId('cam-y-position').inputValue()) - 85)).toBeLessThan(1.5)
-    // await expect(Math.abs(Number(await page.getByTestId('cam-z-position').inputValue()) - 85)).toBeLessThan(1.5)
-
-    await page.getByRole('button', { name: 'Exit Sketch' }).click()
-
-    await bakeInRetries(async () => {
-      await page.mouse.move(700, 400)
-      await page.mouse.wheel(0, -100)
-    }, [0, -85, -85])
-  })
+  )
 
   // TODO: fix after electron migration is merged
   test('Zoom should be consistent when exiting or entering sketches', async ({

package.json

@@ -133,9 +133,9 @@
     "test:unit": "vitest run --mode development --exclude **/jest-component-unit-tests/*",
     "test:unit:components": "jest -c jest-component-unit-tests/jest.config.ts --rootDir jest-component-unit-tests/",
     "test:e2e:web": "cross-env TARGET=web NODE_ENV=development playwright test --config=playwright.config.ts --project=\"Google Chrome\" --grep=@web",
-    "test:e2e:desktop": "cross-env TARGET=desktop playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot",
-    "test:e2e:desktop:local": "cross-env TARGET=desktop npm run tronb:vite:dev && playwright test --config=playwright.electron.config.ts --grep-invert=@snapshot --grep-invert=\"$(curl --silent https://test-analysis-bot.hawk-dinosaur.ts.net/projects/KittyCAD/modeling-app/tests/disabled/regex)\"",
-    "test:e2e:desktop:local-engine": "cross-env TARGET=desktop npm run tronb:vite:dev && playwright test --config=playwright.electron.config.ts --grep-invert='@snapshot|@skipLocalEngine' --grep-invert=\"$(curl --silent https://test-analysis-bot.hawk-dinosaur.ts.net/projects/KittyCAD/modeling-app/tests/disabled/regex)\"",
+    "test:e2e:desktop": "cross-env TARGET=desktop playwright test --config=playwright.electron.config.ts --grep-invert=\"@snapshot|@web\"",
+    "test:e2e:desktop:local": "cross-env TARGET=desktop npm run tronb:vite:dev && playwright test --config=playwright.electron.config.ts --grep-invert=\"@snapshot|@web\" --grep-invert=\"$(curl --silent https://test-analysis-bot.hawk-dinosaur.ts.net/projects/KittyCAD/modeling-app/tests/disabled/regex)\"",
+    "test:e2e:desktop:local-engine": "cross-env TARGET=desktop npm run tronb:vite:dev && playwright test --config=playwright.electron.config.ts --grep-invert=\"@snapshot|@web|@skipLocalEngine\" --grep-invert=\"$(curl --silent https://test-analysis-bot.hawk-dinosaur.ts.net/projects/KittyCAD/modeling-app/tests/disabled/regex)\"",
     "test:unit:local": "npm run simpleserver:bg && npm run test:unit; kill-port 3000"
   },
   "browserslist": {

rust/Cargo.lock

@@ -2,16 +2,6 @@
 # It is not intended for manual editing.
 version = 3
 
-[[package]]
-name = "Inflector"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3"
-dependencies = [
- "lazy_static",
- "regex",
-]
-
 [[package]]
 name = "addr2line"
 version = "0.24.2"
@@ -627,26 +617,22 @@ dependencies = [
 
 [[package]]
 name = "criterion"
-version = "0.5.1"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+checksum = "3bf7af66b0989381bd0be551bd7cc91912a655a58c6918420c9527b1fd8b4679"
 dependencies = [
  "anes",
  "cast",
  "ciborium",
  "clap",
  "criterion-plot",
- "futures",
- "is-terminal",
- "itertools 0.10.5",
+ "itertools 0.13.0",
  "num-traits 0.2.19",
- "once_cell",
  "oorandom",
  "plotters",
  "rayon",
  "regex",
  "serde",
- "serde_derive",
  "serde_json",
  "tinytemplate",
  "tokio",
@@ -715,9 +701,9 @@ dependencies = [
 
 [[package]]
 name = "csscolorparser"
-version = "0.7.0"
+version = "0.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f9a16a848a7fb95dd47ce387ac1ee9a6df879ba784b815537fcd388a1a8288"
+checksum = "5fda6aace1fbef3aa217b27f4c8d7d071ef2a70a5ca51050b1f17d40299d3f16"
 dependencies = [
  "phf",
 ]
@@ -1311,15 +1297,6 @@ dependencies = [
  "digest",
 ]
 
-[[package]]
-name = "home"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "589533453244b0995c858700322199b2becb13b627df2851f64a2775d024abcf"
-dependencies = [
- "windows-sys 0.59.0",
-]
-
 [[package]]
 name = "http"
 version = "0.2.12"
@@ -1815,7 +1792,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-bumper"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "clap",
@@ -1826,26 +1803,16 @@ dependencies = [
 
 [[package]]
 name = "kcl-derive-docs"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
- "Inflector",
- "anyhow",
- "convert_case",
- "expectorate",
- "once_cell",
- "pretty_assertions",
  "proc-macro2",
  "quote",
- "regex",
- "rustfmt-wrapper",
- "serde",
- "serde_tokenstream",
  "syn 2.0.100",
 ]
 
 [[package]]
 name = "kcl-directory-test-macro"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "convert_case",
  "proc-macro2",
@@ -1855,7 +1822,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server"
-version = "0.2.78"
+version = "0.2.79"
 dependencies = [
  "anyhow",
  "clap",
@@ -1876,7 +1843,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-language-server-release"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "clap",
@@ -1896,7 +1863,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-lib"
-version = "0.2.78"
+version = "0.2.79"
 dependencies = [
  "anyhow",
  "approx 0.5.1",
@@ -1973,7 +1940,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-python-bindings"
-version = "0.3.78"
+version = "0.3.79"
 dependencies = [
  "anyhow",
  "kcl-lib",
@@ -1988,7 +1955,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-test-server"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "hyper 0.14.32",
@@ -2001,7 +1968,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-to-core"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "async-trait",
@@ -2015,7 +1982,7 @@ dependencies = [
 
 [[package]]
 name = "kcl-wasm-lib"
-version = "0.1.78"
+version = "0.1.79"
 dependencies = [
  "anyhow",
  "bson",
@@ -3354,19 +3321,6 @@ version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
-[[package]]
-name = "rustfmt-wrapper"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1adc9dfed5cc999077978cc7163b9282c5751c8d39827c4ea8c8c220ca5a440"
-dependencies = [
- "serde",
- "tempfile",
- "thiserror 1.0.69",
- "toml",
- "toolchain_find",
-]
-
 [[package]]
 name = "rustix"
 version = "1.0.2"
@@ -3613,18 +3567,6 @@ dependencies = [
  "serde",
 ]
 
-[[package]]
-name = "serde_tokenstream"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64060d864397305347a78851c51588fd283767e7e7589829e8121d65512340f1"
-dependencies = [
- "proc-macro2",
- "quote",
- "serde",
- "syn 2.0.100",
-]
-
 [[package]]
 name = "serde_urlencoded"
 version = "0.7.1"
@@ -4200,9 +4142,9 @@ dependencies = [
 
 [[package]]
 name = "tokio-tungstenite"
-version = "0.24.0"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edc5f74e248dc973e0dbb7b74c7e0d6fcc301c694ff50049504004ef4d0cdcd9"
+checksum = "7a9daff607c6d2bf6c16fd681ccb7eecc83e4e2cdc1ca067ffaadfca5de7f084"
 dependencies = [
  "futures-util",
  "log",
@@ -4261,19 +4203,6 @@ dependencies = [
  "winnow",
 ]
 
-[[package]]
-name = "toolchain_find"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc8c9a7f0a2966e1acdaf0461023d0b01471eeead645370cf4c3f5cff153f2a"
-dependencies = [
- "home",
- "once_cell",
- "regex",
- "semver",
- "walkdir",
-]
-
 [[package]]
 name = "tower"
 version = "0.4.13"
@@ -4456,21 +4385,20 @@ dependencies = [
 
 [[package]]
 name = "tungstenite"
-version = "0.24.0"
+version = "0.26.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18e5b8366ee7a95b16d32197d0b2604b43a0be89dc5fac9f8e96ccafbaedda8a"
+checksum = "4793cb5e56680ecbb1d843515b23b6de9a75eb04b66643e256a396d43be33c13"
 dependencies = [
- "byteorder",
  "bytes",
  "data-encoding",
  "http 1.3.1",
  "httparse",
  "log",
- "rand 0.8.5",
+ "rand 0.9.0",
  "rustls",
  "rustls-pki-types",
  "sha1",
- "thiserror 1.0.69",
+ "thiserror 2.0.12",
  "utf-8",
 ]
 

rust/kcl-bumper/Cargo.toml

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

rust/kcl-derive-docs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-derive-docs"
 description = "A tool for generating documentation from Rust derive macros"
-version = "0.1.78"
+version = "0.1.79"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
@@ -12,21 +12,9 @@ proc-macro = true
 bench = false
 
 [dependencies]
-Inflector = "0.11.4"
-convert_case = "0.8.0"
-once_cell = "1.21.3"
 proc-macro2 = "1"
 quote = "1"
-regex = "1.11"
-serde = { workspace = true }
-serde_tokenstream = "0.2"
 syn = { version = "2.0.96", features = ["full"] }
 
-[dev-dependencies]
-anyhow = { workspace = true }
-expectorate = "1.1.0"
-pretty_assertions = "1.4.1"
-rustfmt-wrapper = "0.2.1"
-
 [lints]
 workspace = true

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

@@ -149,6 +149,35 @@ pub const TEST_NAMES: &[&str] = &[
     "std-sketch-tangentToEnd-2",
     "std-sketch-tangentToEnd-3",
     "std-sketch-tangentToEnd-4",
+    "std-sketch-profileStart-0",
+    "std-sketch-profileStartX-0",
+    "std-sketch-profileStartY-0",
+    "std-sketch-startProfile-0",
+    "std-sketch-startProfile-1",
+    "std-sketch-startProfile-2",
+    "std-sketch-startSketchOn-0",
+    "std-sketch-startSketchOn-1",
+    "std-sketch-startSketchOn-2",
+    "std-sketch-startSketchOn-3",
+    "std-sketch-startSketchOn-4",
+    "std-sketch-startSketchOn-5",
+    "std-sketch-angledLineThatIntersects-0",
+    "std-sketch-angledLine-0",
+    "std-sketch-arc-0",
+    "std-sketch-arc-1",
+    "std-sketch-bezierCurve-0",
+    "std-sketch-bezierCurve-1",
+    "std-sketch-close-0",
+    "std-sketch-close-1",
+    "std-sketch-involuteCircular-0",
+    "std-sketch-line-0",
+    "std-sketch-subtract2d-0",
+    "std-sketch-subtract2d-1",
+    "std-sketch-tangentialArc-0",
+    "std-sketch-tangentialArc-1",
+    "std-sketch-tangentialArc-2",
+    "std-sketch-xLine-0",
+    "std-sketch-yLine-0",
     "std-solid-appearance-0",
     "std-solid-appearance-1",
     "std-solid-appearance-2",

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

@@ -3,29 +3,6 @@
 #![allow(clippy::style)]
 
 mod example_tests;
-#[cfg(test)]
-mod tests;
-mod unbox;
-
-use std::collections::HashMap;
-
-use convert_case::Casing;
-use inflector::{cases::camelcase::to_camel_case, Inflector};
-use once_cell::sync::Lazy;
-use quote::{format_ident, quote, quote_spanned, ToTokens};
-use regex::Regex;
-use serde::Deserialize;
-use serde_tokenstream::{from_tokenstream, Error};
-use syn::{
-    parse::{Parse, ParseStream},
-    Attribute, Signature, Visibility,
-};
-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_example_test(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -36,845 +13,3 @@ pub fn for_each_example_test(_attr: proc_macro::TokenStream, item: proc_macro::T
 pub fn for_all_example_test(_attr: proc_macro::TokenStream, item: proc_macro::TokenStream) -> proc_macro::TokenStream {
     example_tests::do_for_all_example_test(item.into()).into()
 }
-
-/// Describes an argument of a stdlib function.
-#[derive(Deserialize, Debug)]
-struct ArgMetadata {
-    /// Docs for the argument.
-    docs: String,
-
-    /// If this argument is optional, it should still be included in completion snippets.
-    /// Does not do anything if the argument is already required.
-    #[serde(default)]
-    include_in_snippet: bool,
-
-    /// The snippet should suggest this value for the arg.
-    #[serde(default)]
-    snippet_value: Option<String>,
-
-    /// The snippet should suggest this value for the arg.
-    #[serde(default)]
-    snippet_value_array: Option<Vec<String>>,
-}
-
-#[derive(Deserialize, Debug)]
-struct StdlibMetadata {
-    /// The name of the function in the API.
-    name: String,
-
-    /// Tags for the function.
-    #[serde(default)]
-    tags: Vec<String>,
-
-    /// Whether the function is unpublished.
-    /// Then docs will not be generated.
-    #[serde(default)]
-    unpublished: bool,
-
-    /// Whether the function is deprecated.
-    /// Then specific docs detailing that this is deprecated will be generated.
-    #[serde(default)]
-    deprecated: bool,
-
-    /// Whether the function is displayed in the feature tree.
-    /// If true, calls to the function will be available for display.
-    /// If false, calls to the function will never be displayed.
-    #[serde(default)]
-    feature_tree_operation: bool,
-
-    /// If true, the first argument is unlabeled.
-    /// If false, all arguments require labels.
-    #[serde(default)]
-    unlabeled_first: bool,
-
-    /// Key = argument name, value = argument doc.
-    #[serde(default)]
-    args: HashMap<String, ArgMetadata>,
-}
-
-fn do_stdlib(
-    attr: proc_macro2::TokenStream,
-    item: proc_macro2::TokenStream,
-) -> Result<(proc_macro2::TokenStream, Vec<Error>), Error> {
-    let metadata = from_tokenstream(&attr)?;
-    do_stdlib_inner(metadata, attr, item)
-}
-
-fn do_output(res: Result<(proc_macro2::TokenStream, Vec<Error>), Error>) -> proc_macro::TokenStream {
-    match res {
-        Err(err) => err.to_compile_error().into(),
-        Ok((stdlib_docs, errors)) => {
-            let compiler_errors = errors.iter().map(|err| err.to_compile_error());
-
-            let output = quote! {
-                #stdlib_docs
-                #( #compiler_errors )*
-            };
-
-            output.into()
-        }
-    }
-}
-
-fn do_stdlib_inner(
-    metadata: StdlibMetadata,
-    _attr: proc_macro2::TokenStream,
-    item: proc_macro2::TokenStream,
-) -> Result<(proc_macro2::TokenStream, Vec<Error>), Error> {
-    let ast: ItemFnForSignature = syn::parse2(item.clone())?;
-
-    let mut errors = Vec::new();
-
-    if ast.sig.constness.is_some() {
-        errors.push(Error::new_spanned(
-            &ast.sig.constness,
-            "stdlib functions may not be const functions",
-        ));
-    }
-
-    if ast.sig.unsafety.is_some() {
-        errors.push(Error::new_spanned(
-            &ast.sig.unsafety,
-            "stdlib functions may not be unsafe",
-        ));
-    }
-
-    if ast.sig.abi.is_some() {
-        errors.push(Error::new_spanned(
-            &ast.sig.abi,
-            "stdlib functions may not use an alternate ABI",
-        ));
-    }
-
-    if !ast.sig.generics.params.is_empty() {
-        if ast.sig.generics.params.iter().any(|generic_type| match generic_type {
-            syn::GenericParam::Lifetime(_) => false,
-            syn::GenericParam::Type(_) => true,
-            syn::GenericParam::Const(_) => true,
-        }) {
-            errors.push(Error::new_spanned(
-                &ast.sig.generics,
-                "Stdlib functions may not be generic over types or constants, only lifetimes.",
-            ));
-        }
-    }
-
-    if ast.sig.variadic.is_some() {
-        errors.push(Error::new_spanned(&ast.sig.variadic, "no language C here"));
-    }
-
-    let name = metadata.name;
-
-    // Fail if the name is not camel case.
-    // Remove some known suffix exceptions first.
-    let name_cleaned = name.strip_suffix("2d").unwrap_or(name.as_str());
-    let name_cleaned = name.strip_suffix("3d").unwrap_or(name_cleaned);
-    if !name_cleaned.is_camel_case() {
-        errors.push(Error::new_spanned(
-            &ast.sig.ident,
-            format!("stdlib function names must be in camel case: `{}`", name),
-        ));
-    }
-
-    let name_ident = format_ident!("{}", name.to_case(convert_case::Case::UpperCamel));
-    let name_str = name.to_string();
-
-    let fn_name = &ast.sig.ident;
-    let fn_name_str = fn_name.to_string().replace("inner_", "");
-    let fn_name_ident = format_ident!("{}", fn_name_str);
-    let boxed_fn_name_ident = format_ident!("boxed_{}", fn_name_str);
-    let _visibility = &ast.vis;
-
-    let doc_info = extract_doc_from_attrs(&ast.attrs);
-    let comment_text = {
-        let mut buf = String::new();
-        buf.push_str("Std lib function: ");
-        buf.push_str(&name_str);
-        if let Some(s) = &doc_info.summary {
-            buf.push_str("\n");
-            buf.push_str(&s);
-        }
-        if let Some(s) = &doc_info.description {
-            buf.push_str("\n");
-            buf.push_str(&s);
-        }
-        buf
-    };
-    let description_doc_comment = quote! {
-        #[doc = #comment_text]
-    };
-
-    let summary = if let Some(summary) = doc_info.summary {
-        quote! { #summary }
-    } else {
-        quote! { "" }
-    };
-    let description = if let Some(description) = doc_info.description {
-        quote! { #description }
-    } else {
-        quote! { "" }
-    };
-
-    if doc_info.code_blocks.is_empty() {
-        errors.push(Error::new_spanned(
-            &ast.sig,
-            "stdlib functions must have at least one code block",
-        ));
-    }
-
-    // Make sure the function name is in all the code blocks.
-    for code_block in doc_info.code_blocks.iter() {
-        if !code_block.0.contains(&name) {
-            errors.push(Error::new_spanned(
-                &ast.sig,
-                format!(
-                    "stdlib functions must have the function name `{}` in the code block",
-                    name
-                ),
-            ));
-        }
-    }
-
-    let test_code_blocks = doc_info
-        .code_blocks
-        .iter()
-        .enumerate()
-        .map(|(index, (code_block, norun))| {
-            if !norun {
-                generate_code_block_test(&fn_name_str, code_block, index)
-            } else {
-                quote! {}
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let (cb, norun): (Vec<_>, Vec<_>) = doc_info.code_blocks.into_iter().unzip();
-    let code_blocks = quote! {
-        let code_blocks = vec![#(#cb),*];
-        let norun = vec![#(#norun),*];
-        code_blocks.iter().zip(norun).map(|(cb, norun)| {
-            let program = crate::Program::parse_no_errs(cb).unwrap();
-
-            let mut options: crate::parsing::ast::types::FormatOptions = Default::default();
-            options.insert_final_newline = false;
-            (program.ast.recast(&options, 0), norun)
-        }).collect::<Vec<(String, bool)>>()
-    };
-
-    let tags = metadata
-        .tags
-        .iter()
-        .map(|tag| {
-            quote! { #tag.to_string() }
-        })
-        .collect::<Vec<_>>();
-
-    let deprecated = if metadata.deprecated {
-        quote! { true }
-    } else {
-        quote! { false }
-    };
-
-    let unpublished = if metadata.unpublished {
-        quote! { true }
-    } else {
-        quote! { false }
-    };
-
-    let feature_tree_operation = if metadata.feature_tree_operation {
-        quote! { true }
-    } else {
-        quote! { false }
-    };
-
-    let docs_crate = get_crate(None);
-
-    // When the user attaches this proc macro to a function with the wrong type
-    // signature, the resulting errors can be deeply inscrutable. To attempt to
-    // make failures easier to understand, we inject code that asserts the types
-    // of the various parameters. We do this by calling dummy functions that
-    // require a type that satisfies SharedExtractor or ExclusiveExtractor.
-    let mut arg_types = Vec::new();
-    for (i, arg) in ast.sig.inputs.iter().enumerate() {
-        // Get the name of the argument.
-        let arg_name = match arg {
-            syn::FnArg::Receiver(pat) => {
-                let span = pat.self_token.span.unwrap();
-                span.source_text().unwrap().to_string()
-            }
-            syn::FnArg::Typed(pat) => match &*pat.pat {
-                syn::Pat::Ident(ident) => ident.ident.to_string(),
-                _ => {
-                    errors.push(Error::new_spanned(
-                        &pat.pat,
-                        "stdlib functions may not use destructuring patterns",
-                    ));
-                    continue;
-                }
-            },
-        }
-        .trim_start_matches('_')
-        .to_string();
-        // These aren't really KCL args, they're just state that each stdlib function's impl needs.
-        if arg_name == "exec_state" || arg_name == "args" {
-            continue;
-        }
-
-        let ty = match arg {
-            syn::FnArg::Receiver(pat) => pat.ty.as_ref().into_token_stream(),
-            syn::FnArg::Typed(pat) => pat.ty.as_ref().into_token_stream(),
-        };
-
-        let (ty_string, ty_ident) = clean_ty_string(ty.to_string().as_str());
-
-        let ty_string = rust_type_to_openapi_type(&ty_string);
-        let required = !ty_ident.to_string().starts_with("Option <");
-        let Some(arg_meta) = metadata.args.get(&arg_name) else {
-            errors.push(Error::new_spanned(arg, format!("arg {arg_name} not found")));
-            continue;
-        };
-        let description = arg_meta.docs.clone();
-        let include_in_snippet = required || arg_meta.include_in_snippet;
-        let snippet_value = arg_meta.snippet_value.clone();
-        let snippet_value_array = arg_meta.snippet_value_array.clone();
-        if snippet_value.is_some() && snippet_value_array.is_some() {
-            errors.push(Error::new_spanned(arg, format!("arg {arg_name} has set both snippet_value and snippet_value array, but at most one of these may be set. Please delete one of them.")));
-        }
-        let label_required = !(i == 0 && metadata.unlabeled_first);
-        let camel_case_arg_name = to_camel_case(&arg_name);
-        if ty_string != "ExecState" && ty_string != "Args" {
-            let schema = quote! {
-                generator.root_schema_for::<#ty_ident>()
-            };
-            let q0 = quote! {
-                    name: #camel_case_arg_name.to_string(),
-                    type_: #ty_string.to_string(),
-                    schema: #schema,
-                    required: #required,
-                    label_required: #label_required,
-                    description: #description.to_string(),
-                    include_in_snippet: #include_in_snippet,
-            };
-            let q1 = if let Some(snippet_value) = snippet_value {
-                quote! {
-                    snippet_value: Some(#snippet_value.to_owned()),
-                }
-            } else {
-                quote! {
-                    snippet_value: None,
-                }
-            };
-            let q2 = if let Some(snippet_value_array) = snippet_value_array {
-                quote! {
-                    snippet_value_array: Some(vec![
-                        #(#snippet_value_array.to_owned()),*
-                    ]),
-                }
-            } else {
-                quote! {
-                    snippet_value_array: None,
-                }
-            };
-            arg_types.push(quote! {
-                #docs_crate::StdLibFnArg {
-                #q0
-                #q1
-                #q2
-                }
-            });
-        }
-    }
-
-    let return_type_inner = match &ast.sig.output {
-        syn::ReturnType::Default => quote! { () },
-        syn::ReturnType::Type(_, ty) => {
-            // Get the inside of the result.
-            match &**ty {
-                syn::Type::Path(syn::TypePath { path, .. }) => {
-                    let path = &path.segments;
-                    if path.len() == 1 {
-                        let seg = &path[0];
-                        if seg.ident == "Result" {
-                            if let syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments {
-                                args,
-                                ..
-                            }) = &seg.arguments
-                            {
-                                if args.len() == 2 || args.len() == 1 {
-                                    let mut args = args.iter();
-                                    let ok = args.next().unwrap();
-                                    if let syn::GenericArgument::Type(ty) = ok {
-                                        let ty = unbox(ty.clone());
-                                        quote! { #ty }
-                                    } else {
-                                        quote! { () }
-                                    }
-                                } else {
-                                    quote! { () }
-                                }
-                            } else {
-                                quote! { () }
-                            }
-                        } else {
-                            let ty = unbox(*ty.clone());
-                            quote! { #ty }
-                        }
-                    } else {
-                        quote! { () }
-                    }
-                }
-                _ => {
-                    quote! { () }
-                }
-            }
-        }
-    };
-
-    let ret_ty_string = return_type_inner.to_string().replace(' ', "");
-    let return_type = if !ret_ty_string.is_empty() || ret_ty_string != "()" {
-        let ret_ty_string = rust_type_to_openapi_type(&ret_ty_string);
-        quote! {
-            let schema = generator.root_schema_for::<#return_type_inner>();
-            Some(#docs_crate::StdLibFnArg {
-                name: "".to_string(),
-                type_: #ret_ty_string.to_string(),
-                schema,
-                required: true,
-                label_required: true,
-                description: String::new(),
-                include_in_snippet: true,
-                snippet_value: None,
-                snippet_value_array: None,
-            })
-        }
-    } else {
-        quote! {
-            None
-        }
-    };
-
-    // For reasons that are not well understood unused constants that use the
-    // (default) call_site() Span do not trigger the dead_code lint. Because
-    // defining but not using an endpoint is likely a programming error, we
-    // want to be sure to have the compiler flag this. We force this by using
-    // the span from the name of the function to which this macro was applied.
-    let span = ast.sig.ident.span();
-    let const_struct = quote_spanned! {span=>
-        pub(crate) const #name_ident: #name_ident = #name_ident {};
-    };
-
-    let test_mod_name = format_ident!("test_examples_{}", fn_name_str);
-
-    // The final TokenStream returned will have a few components that reference
-    // `#name_ident`, the name of the function to which this macro was applied...
-    let stream = quote! {
-        #[cfg(test)]
-        mod #test_mod_name {
-            #(#test_code_blocks)*
-        }
-
-        // ... a struct type called `#name_ident` that has no members
-        #[allow(non_camel_case_types, missing_docs)]
-        #description_doc_comment
-        #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, schemars::JsonSchema, ts_rs::TS)]
-        #[ts(export)]
-        pub(crate) struct #name_ident {}
-        // ... a constant of type `#name` whose identifier is also #name_ident
-        #[allow(non_upper_case_globals, missing_docs)]
-        #description_doc_comment
-        #const_struct
-
-        fn #boxed_fn_name_ident(
-            exec_state: &mut crate::execution::ExecState,
-            args: crate::std::Args,
-        ) -> std::pin::Pin<
-            Box<dyn std::future::Future<Output = anyhow::Result<crate::execution::KclValue, crate::errors::KclError>> + Send + '_>,
-        > {
-            Box::pin(#fn_name_ident(exec_state, args))
-        }
-
-        impl #docs_crate::StdLibFn for #name_ident
-        {
-            fn name(&self) -> String {
-                #name_str.to_string()
-            }
-
-            fn summary(&self) -> String {
-                #summary.to_string()
-            }
-
-            fn description(&self) -> String {
-                #description.to_string()
-            }
-
-            fn tags(&self) -> Vec<String> {
-                vec![#(#tags),*]
-            }
-
-            fn args(&self, inline_subschemas: bool) -> Vec<#docs_crate::StdLibFnArg> {
-                let mut settings = schemars::gen::SchemaSettings::openapi3();
-                // We set this to false so we can recurse them later.
-                settings.inline_subschemas = inline_subschemas;
-                let mut generator = schemars::gen::SchemaGenerator::new(settings);
-
-                vec![#(#arg_types),*]
-            }
-
-            fn return_value(&self, inline_subschemas: bool) -> Option<#docs_crate::StdLibFnArg> {
-                let mut settings = schemars::gen::SchemaSettings::openapi3();
-                // We set this to false so we can recurse them later.
-                settings.inline_subschemas = inline_subschemas;
-                let mut generator = schemars::gen::SchemaGenerator::new(settings);
-
-                #return_type
-            }
-
-            fn unpublished(&self) -> bool {
-                #unpublished
-            }
-
-            fn deprecated(&self) -> bool {
-                #deprecated
-            }
-
-            fn feature_tree_operation(&self) -> bool {
-                #feature_tree_operation
-            }
-
-            fn examples(&self) -> Vec<(String, bool)> {
-                #code_blocks
-            }
-
-            fn std_lib_fn(&self) -> crate::std::StdFn {
-                #boxed_fn_name_ident
-            }
-
-            fn clone_box(&self) -> Box<dyn #docs_crate::StdLibFn> {
-                Box::new(self.clone())
-            }
-        }
-
-        #item
-    };
-
-    // Prepend the usage message if any errors were detected.
-    if !errors.is_empty() {
-        errors.insert(0, Error::new_spanned(&ast.sig, ""));
-    }
-
-    Ok((stream, errors))
-}
-
-#[allow(dead_code)]
-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
-    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
-    quote!(#(#compile_errors)*)
-}
-
-fn get_crate(var: Option<String>) -> proc_macro2::TokenStream {
-    if let Some(s) = var {
-        if let Ok(ts) = syn::parse_str(s.as_str()) {
-            return ts;
-        }
-    }
-    quote!(crate::docs)
-}
-
-#[derive(Debug)]
-struct DocInfo {
-    pub summary: Option<String>,
-    pub description: Option<String>,
-    pub code_blocks: Vec<(String, bool)>,
-}
-
-fn extract_doc_from_attrs(attrs: &[syn::Attribute]) -> DocInfo {
-    let doc = syn::Ident::new("doc", proc_macro2::Span::call_site());
-    let raw_lines = attrs.iter().flat_map(|attr| {
-        if let syn::Meta::NameValue(nv) = &attr.meta {
-            if nv.path.is_ident(&doc) {
-                if let syn::Expr::Lit(syn::ExprLit {
-                    lit: syn::Lit::Str(s), ..
-                }) = &nv.value
-                {
-                    return normalize_comment_string(s.value());
-                }
-            }
-        }
-        Vec::new()
-    });
-
-    // Parse any code blocks from the doc string.
-    let mut code_blocks: Vec<(String, bool)> = Vec::new();
-    let mut code_block: Option<(String, bool)> = None;
-    let mut parsed_lines = Vec::new();
-    for line in raw_lines {
-        if line.starts_with("```") {
-            if let Some((inner_code_block, norun)) = code_block {
-                code_blocks.push((inner_code_block.trim().to_owned(), norun));
-                code_block = None;
-            } else {
-                let norun = line.contains("kcl,norun") || line.contains("kcl,no_run");
-                code_block = Some((String::new(), norun));
-            }
-
-            continue;
-        }
-        if let Some((code_block, _)) = &mut code_block {
-            code_block.push_str(&line);
-            code_block.push('\n');
-        } else {
-            parsed_lines.push(line);
-        }
-    }
-
-    if let Some((code_block, norun)) = code_block {
-        code_blocks.push((code_block.trim().to_string(), norun));
-    }
-
-    let mut summary = None;
-    let mut description: Option<String> = None;
-    for line in parsed_lines {
-        if line.is_empty() {
-            if let Some(desc) = &mut description {
-                // Handle fully blank comments as newlines we keep.
-                if !desc.is_empty() && !desc.ends_with('\n') {
-                    if desc.ends_with(' ') {
-                        desc.pop().unwrap();
-                    }
-                    desc.push_str("\n\n");
-                }
-            } else if summary.is_some() {
-                description = Some(String::new());
-            }
-            continue;
-        }
-
-        if let Some(desc) = &mut description {
-            desc.push_str(&line);
-            // Default to space-separating comment fragments.
-            desc.push(' ');
-            continue;
-        }
-
-        if summary.is_none() {
-            summary = Some(String::new());
-        }
-        match &mut summary {
-            Some(summary) => {
-                summary.push_str(&line);
-                // Default to space-separating comment fragments.
-                summary.push(' ');
-            }
-            None => unreachable!(),
-        }
-    }
-
-    // Trim the summary and description.
-    if let Some(s) = &mut summary {
-        while s.ends_with(' ') || s.ends_with('\n') {
-            s.pop().unwrap();
-        }
-
-        if s.is_empty() {
-            summary = None;
-        }
-    }
-
-    if let Some(d) = &mut description {
-        while d.ends_with(' ') || d.ends_with('\n') {
-            d.pop().unwrap();
-        }
-
-        if d.is_empty() {
-            description = None;
-        }
-    }
-
-    DocInfo {
-        summary,
-        description,
-        code_blocks,
-    }
-}
-
-fn normalize_comment_string(s: String) -> Vec<String> {
-    s.split('\n')
-        .map(|s| {
-            // Rust-style comments are intrinsically single-line.
-            // We only want to trim a single space character from the start of
-            // a line, and only if it's the first character.
-            s.strip_prefix(' ').unwrap_or(s).trim_end().to_owned()
-        })
-        .collect()
-}
-
-/// 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,
-    pub sig: Signature,
-    pub _block: proc_macro2::TokenStream,
-}
-
-impl Parse for ItemFnForSignature {
-    fn parse(input: ParseStream) -> syn::parse::Result<Self> {
-        let attrs = input.call(Attribute::parse_outer)?;
-        let vis: Visibility = input.parse()?;
-        let sig: Signature = input.parse()?;
-        let block = input.parse()?;
-        Ok(ItemFnForSignature {
-            attrs,
-            vis,
-            sig,
-            _block: block,
-        })
-    }
-}
-
-fn clean_ty_string(t: &str) -> (String, proc_macro2::TokenStream) {
-    let mut ty_string = t
-        .replace("& 'a", "")
-        .replace('&', "")
-        .replace("mut", "")
-        .replace("< 'a >", "")
-        .replace(' ', "");
-    if ty_string.starts_with("ExecState") {
-        ty_string = "ExecState".to_string();
-    }
-    if ty_string.starts_with("Args") {
-        ty_string = "Args".to_string();
-    }
-    let ty_string = ty_string.trim().to_string();
-    let ty_ident = if ty_string.starts_with("Vec<") {
-        let ty_string = ty_string.trim_start_matches("Vec<").trim_end_matches('>');
-        let (_, ty_ident) = clean_ty_string(&ty_string);
-        quote! {
-           Vec<#ty_ident>
-        }
-    } else if ty_string.starts_with("kittycad::types::") {
-        let ty_string = ty_string.trim_start_matches("kittycad::types::").trim_end_matches('>');
-        let ty_ident = format_ident!("{}", ty_string);
-        quote! {
-           kittycad::types::#ty_ident
-        }
-    } else if ty_string.starts_with("Option<") {
-        let ty_string = ty_string.trim_start_matches("Option<").trim_end_matches('>');
-        let (_, ty_ident) = clean_ty_string(&ty_string);
-        quote! {
-           Option<#ty_ident>
-        }
-    } else if let Some((inner_array_type, num)) = parse_array_type(&ty_string) {
-        let ty_string = inner_array_type.to_owned();
-        let (_, ty_ident) = clean_ty_string(&ty_string);
-        quote! {
-           [#ty_ident; #num]
-        }
-    } else if ty_string.starts_with("Box<") {
-        let ty_string = ty_string.trim_start_matches("Box<").trim_end_matches('>');
-        let (_, ty_ident) = clean_ty_string(&ty_string);
-        quote! {
-           #ty_ident
-        }
-    } else {
-        let ty_ident = format_ident!("{}", ty_string);
-        quote! {
-           #ty_ident
-        }
-    };
-
-    (ty_string, ty_ident)
-}
-
-fn rust_type_to_openapi_type(t: &str) -> String {
-    let mut t = t.to_string();
-    // Turn vecs into arrays.
-    // TODO: handle nested types
-    if t.starts_with("Vec<") {
-        t = t.replace("Vec<", "[").replace('>', "]");
-    }
-    if t.starts_with("Box<") {
-        t = t.replace("Box<", "").replace('>', "");
-    }
-    if t.starts_with("Option<") {
-        t = t.replace("Option<", "").replace('>', "");
-    }
-
-    if t == "[TyF64;2]" {
-        return "Point2d".to_owned();
-    }
-    if t == "[TyF64;3]" {
-        return "Point3d".to_owned();
-    }
-
-    if let Some((inner_type, _length)) = parse_array_type(&t) {
-        t = format!("[{inner_type}]")
-    }
-
-    if t == "f64" || t == "TyF64" || t == "u32" || t == "NonZeroU32" {
-        return "number".to_string();
-    } else if t == "str" || t == "String" {
-        return "string".to_string();
-    } else {
-        return t.replace("f64", "number").replace("TyF64", "number").to_string();
-    }
-}
-
-fn parse_array_type(type_name: &str) -> Option<(&str, usize)> {
-    static RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"\[([a-zA-Z0-9<>]+); ?(\d+)\]").unwrap());
-    let cap = RE.captures(type_name)?;
-    let inner_type = cap.get(1)?;
-    let length = cap.get(2)?.as_str().parse().ok()?;
-    Some((inner_type.as_str(), length))
-}
-
-// For each kcl code block, we want to generate a test that checks that the
-// code block is valid kcl code and compiles and executes.
-fn generate_code_block_test(fn_name: &str, code_block: &str, index: usize) -> proc_macro2::TokenStream {
-    let test_name = format_ident!("kcl_test_example_{}{}", fn_name, index);
-    let test_name_mock = format_ident!("test_mock_example_{}{}", fn_name, index);
-    let output_test_name_str = format!("serial_test_example_{}{}", fn_name, index);
-
-    quote! {
-        #[tokio::test(flavor = "multi_thread")]
-        async fn #test_name_mock() -> miette::Result<()> {
-            let program = crate::Program::parse_no_errs(#code_block).unwrap();
-            let ctx = crate::ExecutorContext {
-                engine: std::sync::Arc::new(Box::new(crate::engine::conn_mock::EngineConnection::new().await.unwrap())),
-                fs: std::sync::Arc::new(crate::fs::FileManager::new()),
-                stdlib: std::sync::Arc::new(crate::std::StdLib::new()),
-                settings: Default::default(),
-                context_type: crate::execution::ContextType::Mock,
-            };
-
-            if let Err(e) = ctx.run(&program, &mut crate::execution::ExecState::new(&ctx)).await {
-                    return Err(miette::Report::new(crate::errors::Report {
-                        error: e.error,
-                        filename: format!("{}{}", #fn_name, #index),
-                        kcl_source: #code_block.to_string(),
-                    }));
-            }
-            Ok(())
-        }
-
-        #[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-        async fn #test_name() -> miette::Result<()> {
-            let code = #code_block;
-            // Note, `crate` must be kcl_lib
-            let result = match crate::test_server::execute_and_snapshot(code, None).await {
-                Err(crate::errors::ExecError::Kcl(e)) => {
-                    return Err(miette::Report::new(crate::errors::Report {
-                        error: e.error,
-                        filename: format!("{}{}", #fn_name, #index),
-                        kcl_source: #code_block.to_string(),
-                    }));
-                }
-                Err(other_err)=> panic!("{}", other_err),
-                Ok(img) => img,
-            };
-            twenty_twenty::assert_image(&format!("tests/outputs/{}.png", #output_test_name_str), &result, 0.99);
-            Ok(())
-        }
-    }
-}

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

@@ -1,508 +0,0 @@
-use anyhow::Result;
-use quote::quote;
-
-use crate::{do_stdlib, parse_array_type};
-
-fn clean_text(s: &str) -> String {
-    // Add newlines after end-braces at <= two levels of indentation.
-    if cfg!(not(windows)) {
-        let regex = regex::Regex::new(r"(})(\n\s{0,8}[^} ])").unwrap();
-        regex.replace_all(s, "$1\n$2").to_string()
-    } else {
-        let regex = regex::Regex::new(r"(})(\r\n\s{0,8}[^} ])").unwrap();
-        regex.replace_all(s, "$1\r\n$2").to_string()
-    }
-}
-
-/// Format a TokenStream as a string and run `rustfmt` on the result.
-fn get_text_fmt(output: &proc_macro2::TokenStream) -> Result<String> {
-    // Format the file with rustfmt.
-    let content = rustfmt_wrapper::rustfmt(output).unwrap();
-
-    Ok(clean_text(&content))
-}
-
-#[test]
-fn test_get_inner_array_type() {
-    for (expected, input) in [
-        (Some(("f64", 2)), "[f64;2]"),
-        (Some(("String", 2)), "[String; 2]"),
-        (Some(("Option<String>", 12)), "[Option<String>;12]"),
-        (Some(("Option<String>", 12)), "[Option<String>; 12]"),
-    ] {
-        let actual = parse_array_type(input);
-        assert_eq!(actual, expected);
-    }
-}
-
-#[test]
-fn test_args_with_refs() {
-    let (item, mut errors) = do_stdlib(
-        quote! {
-            name = "someFn",
-            args = {
-                data = { docs = "The data for this function"},
-            },
-        },
-        quote! {
-            /// Docs
-            /// ```
-            /// someFn()
-            /// ```
-            fn someFn(
-                data: &'a str,
-            ) -> i32 {
-                3
-            }
-        },
-    )
-    .unwrap();
-    if let Some(e) = errors.pop() {
-        panic!("{e}");
-    }
-    expectorate::assert_contents("tests/args_with_refs.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_args_with_lifetime() {
-    let (item, mut errors) = do_stdlib(
-        quote! {
-            name = "someFn",
-            args = {
-                data = { docs = "Arg for the function" },
-            }
-        },
-        quote! {
-            /// Docs
-            /// ```
-            /// someFn()
-            /// ```
-            fn someFn<'a>(
-                data: Foo<'a>,
-            ) -> i32 {
-                3
-            }
-        },
-    )
-    .unwrap();
-    if let Some(e) = errors.pop() {
-        panic!("{e}");
-    }
-    expectorate::assert_contents("tests/args_with_lifetime.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_args_with_exec_state() {
-    let (item, mut errors) = do_stdlib(
-        quote! {
-            name = "someFunction",
-        },
-        quote! {
-            /// Docs
-            /// ```
-            /// someFunction()
-            /// ```
-            fn inner_some_function<'a>(
-                exec_state: &mut ExecState,
-                args: &Args,
-            ) -> i32 {
-                3
-            }
-        },
-    )
-    .unwrap();
-    if let Some(e) = errors.pop() {
-        panic!("{e}");
-    }
-    expectorate::assert_contents("tests/test_args_with_exec_state.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_line_to() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "lineTo",
-            args = {
-                data = { docs = "the sketch you're adding the line to" },
-                sketch = { docs = "the sketch you're adding the line to" },
-            }
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// lineTo
-            /// ```
-            fn inner_line_to(
-                data: LineToData,
-                sketch: Sketch,
-                args: &Args,
-            ) -> Result<Sketch, KclError> {
-                Ok(())
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/lineTo.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_min() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "min",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// min
-            /// ```
-            fn inner_min(
-                /// The args to do shit to.
-                args: Vec<f64>
-            ) -> f64 {
-                let mut min = std::f64::MAX;
-                for arg in args.iter() {
-                    if *arg < min {
-                        min = *arg;
-                    }
-                }
-
-                 min
-            }
-        },
-    )
-    .unwrap();
-    let _expected = quote! {};
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/min.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_show() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "show",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// show
-            /// ```
-            fn inner_show(
-                /// The args to do shit to.
-                _args: Vec<f64>
-            ) {
-            }
-        },
-    )
-    .unwrap();
-    let _expected = quote! {};
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/show.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_box() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "show",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// show
-            /// ```
-            fn inner_show(
-                /// The args to do shit to.
-                args: Box<f64>
-            ) -> Box<f64> {
-                args
-            }
-        },
-    )
-    .unwrap();
-    let _expected = quote! {};
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/box.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_option() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "show",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// show
-            /// ```
-            fn inner_show(
-                /// The args to do shit to.
-                args: Option<f64>
-            ) -> Result<Box<f64>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/option.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_array() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "show",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// show
-            /// ```
-            fn inner_show(
-                /// The args to do shit to.
-                args: [f64; 2]
-            ) -> Result<Box<f64>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/array.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_option_input_format() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "import",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// import
-            /// ```
-            fn inner_import(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Box<f64>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/option_input_format.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_return_vec_sketch() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "import",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// import
-            /// ```
-            fn inner_import(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Sketch>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/return_vec_sketch.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_return_vec_box_sketch() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "import",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is code.
-            /// It does other shit.
-            /// import
-            /// ```
-            fn inner_import(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Box<Sketch>>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/return_vec_box_sketch.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_doc_comment_with_code() {
-    let (item, errors) = do_stdlib(
-        quote! {
-            name = "myFunc",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// myFunc
-            /// ```
-            fn inner_my_func(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Box<Sketch>>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(errors.is_empty(), "{errors:?}");
-    expectorate::assert_contents("tests/doc_comment_with_code.gen", &get_text_fmt(&item).unwrap());
-}
-
-#[test]
-fn test_stdlib_fail_non_camel_case() {
-    let (_, errors) = do_stdlib(
-        quote! {
-            name = "import_thing",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// ```
-            fn inner_import_thing(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Box<Sketch>>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(!errors.is_empty());
-    assert_eq!(
-        errors[1].to_string(),
-        "stdlib function names must be in camel case: `import_thing`"
-    );
-}
-
-#[test]
-fn test_stdlib_fail_no_code_block() {
-    let (_, errors) = do_stdlib(
-        quote! {
-            name = "import",
-        },
-        quote! {
-            fn inner_import(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Box<Sketch>>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(!errors.is_empty());
-    assert_eq!(
-        errors[1].to_string(),
-        "stdlib functions must have at least one code block"
-    );
-}
-
-#[test]
-fn test_stdlib_fail_name_not_in_code_block() {
-    let (_, errors) = do_stdlib(
-        quote! {
-            name = "import",
-        },
-        quote! {
-            /// This is some function.
-            /// It does shit.
-            ///
-            /// ```
-            /// This is another code block.
-            /// yes sirrr.
-            /// ```
-            fn inner_import(
-                /// The args to do shit to.
-                args: Option<kittycad::types::InputFormat>
-            ) -> Result<Vec<Box<Sketch>>> {
-                args
-            }
-        },
-    )
-    .unwrap();
-
-    assert!(!errors.is_empty());
-    assert_eq!(
-        errors[1].to_string(),
-        "stdlib functions must have the function name `import` in the code block"
-    );
-}

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

@@ -1,91 +0,0 @@
-// Unbox a Vec<Box<T>> to Vec<T>.
-// Unbox a Box<T> to T.
-pub(crate) fn unbox(t: syn::Type) -> syn::Type {
-    unbox_inner(unbox_vec(t))
-}
-
-// Unbox a syn::Type that is boxed to the inner object.
-fn unbox_inner(t: syn::Type) -> syn::Type {
-    match t {
-        syn::Type::Path(syn::TypePath { ref path, .. }) => {
-            let path = &path.segments;
-            if path.len() == 1 {
-                let seg = &path[0];
-                if seg.ident == "Box" {
-                    if let syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments { args, .. }) =
-                        &seg.arguments
-                    {
-                        if args.len() == 1 {
-                            let mut args = args.iter();
-                            let ok = args.next().unwrap();
-                            if let syn::GenericArgument::Type(ty) = ok {
-                                return ty.clone();
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        _ => {
-            return t;
-        }
-    }
-    t
-}
-
-// For a Vec<Box<T>> return Vec<T>.
-// For a Vec<T> return Vec<T>.
-fn unbox_vec(t: syn::Type) -> syn::Type {
-    match t {
-        syn::Type::Path(syn::TypePath { ref path, .. }) => {
-            let path = &path.segments;
-            if path.len() == 1 {
-                let seg = &path[0];
-                if seg.ident == "Vec" {
-                    if let syn::PathArguments::AngleBracketed(syn::AngleBracketedGenericArguments { args, .. }) =
-                        &seg.arguments
-                    {
-                        if args.len() == 1 {
-                            let mut args = args.iter();
-                            let ok = args.next().unwrap();
-                            if let syn::GenericArgument::Type(ty) = ok {
-                                let unboxed = unbox(ty.clone());
-                                // Wrap it back in a vec.
-                                let wrapped = syn::Type::Path(syn::TypePath {
-                                    qself: None,
-                                    path: syn::Path {
-                                        leading_colon: None,
-                                        segments: {
-                                            let mut segments = syn::punctuated::Punctuated::new();
-                                            segments.push_value(syn::PathSegment {
-                                                ident: syn::Ident::new("Vec", proc_macro2::Span::call_site()),
-                                                arguments: syn::PathArguments::AngleBracketed(
-                                                    syn::AngleBracketedGenericArguments {
-                                                        colon2_token: None,
-                                                        lt_token: syn::token::Lt::default(),
-                                                        args: {
-                                                            let mut args = syn::punctuated::Punctuated::new();
-                                                            args.push_value(syn::GenericArgument::Type(unboxed));
-                                                            args
-                                                        },
-                                                        gt_token: syn::token::Gt::default(),
-                                                    },
-                                                ),
-                                            });
-                                            segments
-                                        },
-                                    },
-                                });
-                                return wrapped;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        _ => {
-            return t;
-        }
-    }
-    t
-}

rust/kcl-directory-test-macro/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-directory-test-macro"
 description = "A tool for generating tests from a directory of kcl files"
-version = "0.1.78"
+version = "0.1.79"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"

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

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

rust/kcl-language-server/Cargo.toml

@@ -2,7 +2,7 @@
 name = "kcl-language-server"
 description = "A language server for KCL."
 authors = ["KittyCAD Inc <kcl@kittycad.io>"]
-version = "0.2.78"
+version = "0.2.79"
 edition = "2021"
 license = "MIT"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

rust/kcl-lib/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "kcl-lib"
 description = "KittyCAD Language implementation and tools"
-version = "0.2.78"
+version = "0.2.79"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
@@ -31,7 +31,7 @@ clap = { version = "4.5.36", default-features = false, optional = true, features
     "derive",
 ] }
 convert_case = "0.8.0"
-csscolorparser = "0.7.0"
+csscolorparser = "0.7.2"
 dashmap = { workspace = true }
 dhat = { version = "0.3", optional = true }
 fnv = "1.0.7"
@@ -107,7 +107,7 @@ web-sys = { version = "0.3.76", features = ["console"] }
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 instant = "0.1.13"
 tokio = { workspace = true, features = ["full"] }
-tokio-tungstenite = { version = "0.24.0", features = [
+tokio-tungstenite = { version = "0.26.2", features = [
     "rustls-tls-native-roots",
 ] }
 tower-lsp = { workspace = true, features = ["proposed", "default"] }
@@ -130,7 +130,7 @@ tabled = ["dep:tabled"]
 [dev-dependencies]
 approx = "0.5"
 base64 = "0.22.1"
-criterion = { version = "0.5.1", features = ["async_tokio"] }
+criterion = { version = "0.6.0", features = ["async_tokio"] }
 expectorate = "1.1.0"
 handlebars = "6.3.2"
 image = { version = "0.25.6", default-features = false, features = ["png"] }

rust/kcl-lib/benches/benchmark_kcl_samples.rs

@@ -1,9 +1,10 @@
 use std::{
     fs,
+    hint::black_box,
     path::{Path, PathBuf},
 };
 
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use criterion::{criterion_group, criterion_main, Criterion};
 
 const IGNORE_DIRS: [&str; 2] = ["step", "screenshots"];
 

rust/kcl-lib/benches/compiler_benchmark_criterion.rs

@@ -1,4 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, Criterion};
 
 pub fn bench_parse(c: &mut Criterion) {
     for (name, file) in [

rust/kcl-lib/benches/lsp_semantic_tokens_benchmark_criterion.rs

@@ -1,4 +1,6 @@
-use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
+use std::hint::black_box;
+
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use kcl_lib::kcl_lsp_server;
 use tokio::runtime::Runtime;
 use tower_lsp::LanguageServer;

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

@@ -762,7 +762,7 @@ async fn kcl_test_stdlib_kcl_error_right_code_path() {
     };
     assert_eq!(
         err.error.message(),
-        "This function requires a keyword argument 'center'"
+        "This function requires a keyword argument `center`"
     );
 }
 
@@ -1230,10 +1230,7 @@ secondSketch = startSketchOn(part001, face = '')
     let result = execute_and_snapshot(code, None).await;
     let err = result.unwrap_err();
     let err = err.as_kcl_error().unwrap();
-    assert_eq!(
-        err.message(),
-        "This function expected the input argument to be tag but it's actually of type string"
-    );
+    assert_eq!(err.message(), "face requires a value with type `tag`, but found string");
 }
 
 #[tokio::test(flavor = "multi_thread")]
@@ -1684,10 +1681,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have an x constrained angle of 90 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(70, 111, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(70, 111, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(70, 111, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1709,10 +1712,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have an x constrained angle of 270 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(70, 112, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(70, 112, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(70, 112, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1734,10 +1743,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have a y constrained angle of 0 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(70, 110, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(70, 110, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(70, 110, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1759,10 +1774,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(70, 112, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(70, 112, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(70, 112, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1784,10 +1805,16 @@ extrusion = extrude(sketch001, length = 10)
     assert_eq!(err.message(), "Cannot have an x constrained angle of 90 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(66, 116, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(66, 116, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(66, 116, ModuleId::default()),
+                fn_name: None,
+            }
+        ]
     );
 }
 
@@ -1809,10 +1836,16 @@ extrusion = extrude(sketch001, length = 10)
     assert_eq!(err.message(), "Cannot have an x constrained angle of 270 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(66, 117, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(66, 117, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(66, 117, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1836,10 +1869,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have a y constrained angle of 0 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(95, 130, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(95, 130, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(95, 130, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1863,10 +1902,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(95, 132, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(95, 132, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(95, 132, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1890,10 +1935,16 @@ example = extrude(exampleSketch, length = 10)
     assert_eq!(err.message(), "Cannot have a y constrained angle of 180 degrees");
     assert_eq!(
         err.backtrace(),
-        vec![BacktraceItem {
-            source_range: SourceRange::new(95, 133, ModuleId::default()),
-            fn_name: Some("angledLine".to_owned())
-        }]
+        vec![
+            BacktraceItem {
+                source_range: SourceRange::new(95, 133, ModuleId::default()),
+                fn_name: Some("angledLine".to_owned())
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(95, 133, ModuleId::default()),
+                fn_name: None
+            }
+        ]
     );
 }
 
@@ -1911,12 +1962,13 @@ someFunction('INVALID')
     let err = err.as_kcl_error().unwrap();
     assert_eq!(
         err.message(),
-        "This function expected the input argument to be Solid or Plane but it's actually of type string"
+        "The input argument of `startSketchOn` requires a value with type `Solid | Plane`, but found string"
     );
     assert_eq!(
         err.source_ranges(),
         vec![
             SourceRange::new(46, 55, ModuleId::default()),
+            SourceRange::new(32, 56, ModuleId::default()),
             SourceRange::new(60, 83, ModuleId::default()),
         ]
     );
@@ -1925,6 +1977,10 @@ someFunction('INVALID')
         vec![
             BacktraceItem {
                 source_range: SourceRange::new(46, 55, ModuleId::default()),
+                fn_name: Some("startSketchOn".to_owned()),
+            },
+            BacktraceItem {
+                source_range: SourceRange::new(32, 56, ModuleId::default()),
                 fn_name: Some("someFunction".to_owned()),
             },
             BacktraceItem {

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

@@ -2,48 +2,11 @@ use std::{collections::HashMap, fs, path::Path};
 
 use anyhow::Result;
 use base64::Engine;
-use convert_case::Casing;
-use indexmap::IndexMap;
-use itertools::Itertools;
 use serde_json::json;
 use tokio::task::JoinSet;
 
 use super::kcl_doc::{ConstData, DocData, ExampleProperties, FnData, ModData, TyData};
-use crate::{
-    docs::{StdLibFn, DECLARED_TYPES},
-    std::StdLib,
-    ExecutorContext,
-};
-
-// Types with special handling.
-const SPECIAL_TYPES: [&str; 4] = ["TagDeclarator", "TagIdentifier", "Start", "End"];
-
-const TYPE_REWRITES: [(&str, &str); 11] = [
-    ("TagNode", "TagDeclarator"),
-    ("SketchData", "Plane | Solid"),
-    ("SketchOrSurface", "Sketch | Plane | Face"),
-    ("SketchSurface", "Plane | Face"),
-    ("SolidOrImportedGeometry", "[Solid] | ImportedGeometry"),
-    (
-        "SolidOrSketchOrImportedGeometry",
-        "[Solid] | [Sketch] | ImportedGeometry",
-    ),
-    ("KclValue", "any"),
-    ("[KclValue]", "[any]"),
-    ("FaceTag", "TagIdentifier | Start | End"),
-    ("GeometryWithImportedGeometry", "Solid | Sketch | ImportedGeometry"),
-    ("SweepPath", "Sketch | Helix"),
-];
-
-fn rename_type(input: &str) -> &str {
-    for (i, o) in TYPE_REWRITES {
-        if input == i {
-            return o;
-        }
-    }
-
-    input
-}
+use crate::ExecutorContext;
 
 fn init_handlebars() -> Result<handlebars::Handlebars<'static>> {
     let mut hbs = handlebars::Handlebars::new();
@@ -104,7 +67,7 @@ fn init_handlebars() -> Result<handlebars::Handlebars<'static>> {
     Ok(hbs)
 }
 
-fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &ModData) -> Result<()> {
+fn generate_index(kcl_lib: &ModData) -> Result<()> {
     let hbs = init_handlebars()?;
 
     let mut functions = HashMap::new();
@@ -115,31 +78,6 @@ fn generate_index(combined: &IndexMap<String, Box<dyn StdLibFn>>, kcl_lib: &ModD
     let mut types = HashMap::new();
     types.insert("Primitive types".to_owned(), Vec::new());
 
-    for key in combined.keys() {
-        let internal_fn = combined
-            .get(key)
-            .ok_or_else(|| anyhow::anyhow!("Failed to get internal function: {}", key))?;
-
-        if internal_fn.unpublished() || internal_fn.deprecated() {
-            continue;
-        }
-
-        let tags = internal_fn.tags();
-        let module = tags.first().map(|s| format!("std::{s}")).unwrap_or("std".to_owned());
-
-        functions
-            .entry(module.to_owned())
-            .or_default()
-            .push((internal_fn.name(), format!("/docs/kcl-std/{}", internal_fn.name())));
-    }
-
-    for name in SPECIAL_TYPES {
-        types
-            .get_mut("Primitive types")
-            .unwrap()
-            .push((name.to_owned(), format!("/docs/kcl-lang/types#{name}")));
-    }
-
     for d in kcl_lib.all_docs() {
         if d.hide() {
             continue;
@@ -257,8 +195,8 @@ fn generate_example(index: usize, src: &str, props: &ExampleProperties, file_nam
     }))
 }
 
-fn generate_type_from_kcl(ty: &TyData, file_name: String, example_name: String) -> Result<()> {
-    if ty.properties.doc_hidden || !DECLARED_TYPES.contains(&&*ty.name) {
+fn generate_type_from_kcl(ty: &TyData, file_name: String, example_name: String, kcl_std: &ModData) -> Result<()> {
+    if ty.properties.doc_hidden {
         return Ok(());
     }
 
@@ -282,18 +220,14 @@ fn generate_type_from_kcl(ty: &TyData, file_name: String, example_name: String)
     });
 
     let output = hbs.render("kclType", &data)?;
-    let output = cleanup_types(&output);
+    let output = cleanup_types(&output, kcl_std);
     expectorate::assert_contents(format!("../../docs/kcl-std/{}.md", file_name), &output);
 
     Ok(())
 }
 
-fn generate_mod_from_kcl(m: &ModData, file_name: String, combined: &IndexMap<String, Box<dyn StdLibFn>>) -> Result<()> {
-    fn list_items(
-        m: &ModData,
-        namespace: &str,
-        combined: &IndexMap<String, Box<dyn StdLibFn>>,
-    ) -> Vec<gltf_json::Value> {
+fn generate_mod_from_kcl(m: &ModData, file_name: String) -> Result<()> {
+    fn list_items(m: &ModData, namespace: &str) -> Vec<gltf_json::Value> {
         let mut items: Vec<_> = m
             .children
             .iter()
@@ -301,25 +235,6 @@ fn generate_mod_from_kcl(m: &ModData, file_name: String, combined: &IndexMap<Str
             .map(|(_, v)| (v.preferred_name().to_owned(), v.file_name()))
             .collect();
 
-        if namespace == "I:" {
-            // Add in functions declared in Rust
-            items.extend(
-                combined
-                    .values()
-                    .filter(|f| {
-                        if f.unpublished() || f.deprecated() {
-                            return false;
-                        }
-
-                        let tags = f.tags();
-                        let module = tags.first().map(|s| format!("std::{s}")).unwrap_or("std".to_owned());
-
-                        module == m.qual_name
-                    })
-                    .map(|f| (f.name(), f.name())),
-            )
-        }
-
         items.sort();
         items
             .into_iter()
@@ -333,9 +248,9 @@ fn generate_mod_from_kcl(m: &ModData, file_name: String, combined: &IndexMap<Str
     }
     let hbs = init_handlebars()?;
 
-    let functions = list_items(m, "I:", combined);
-    let modules = list_items(m, "M:", combined);
-    let types = list_items(m, "T:", combined);
+    let functions = list_items(m, "I:");
+    let modules = list_items(m, "M:");
+    let types = list_items(m, "T:");
 
     let data = json!({
         "name": m.name,
@@ -391,7 +306,7 @@ fn generate_function_from_kcl(
         json!({
             "name": arg.name,
             "type_": arg.ty,
-            "description": docs.or_else(|| arg.ty.as_ref().and_then(|t| super::docs_for_type(t, kcl_std))).unwrap_or_default(),
+            "description": docs.or_else(|| arg.ty.as_ref().and_then(|t| docs_for_type(t, kcl_std))).unwrap_or_default(),
             "required": arg.kind.required(),
         })
     }).collect::<Vec<_>>();
@@ -408,18 +323,30 @@ fn generate_function_from_kcl(
         "return_value": function.return_type.as_ref().map(|t| {
             json!({
                 "type_": t,
-                "description": super::docs_for_type(t, kcl_std).unwrap_or_default(),
+                "description": docs_for_type(t, kcl_std).unwrap_or_default(),
             })
         }),
     });
 
     let output = hbs.render("function", &data)?;
-    let output = &cleanup_types(&output);
+    let output = &cleanup_types(&output, kcl_std);
     expectorate::assert_contents(format!("../../docs/kcl-std/{}.md", file_name), output);
 
     Ok(())
 }
 
+fn docs_for_type(ty: &str, kcl_std: &ModData) -> Option<String> {
+    let key = if ty.starts_with("number") { "number" } else { ty };
+
+    if !key.contains('|') && !key.contains('[') {
+        if let Some(data) = kcl_std.find_by_name(key) {
+            return data.summary().cloned();
+        }
+    }
+
+    None
+}
+
 fn generate_const_from_kcl(cnst: &ConstData, file_name: String, example_name: String) -> Result<()> {
     if cnst.properties.doc_hidden {
         return Ok(());
@@ -450,83 +377,7 @@ fn generate_const_from_kcl(cnst: &ConstData, file_name: String, example_name: St
     Ok(())
 }
 
-fn generate_function(internal_fn: Box<dyn StdLibFn>, kcl_std: &ModData) -> Result<()> {
-    let hbs = init_handlebars()?;
-
-    if internal_fn.unpublished() {
-        return Ok(());
-    }
-
-    let fn_name = internal_fn.name();
-    let snake_case_name = clean_function_name(&fn_name);
-
-    let examples: Vec<serde_json::Value> = internal_fn
-        .examples()
-        .iter()
-        .enumerate()
-        .map(|(index, (example, norun))| {
-            let image_base64 = if !norun {
-                let image_path = format!(
-                    "{}/tests/outputs/serial_test_example_{}{}.png",
-                    env!("CARGO_MANIFEST_DIR"),
-                    snake_case_name,
-                    index
-                );
-                let image_data =
-                    std::fs::read(&image_path).unwrap_or_else(|_| panic!("Failed to read image file: {}", image_path));
-                base64::engine::general_purpose::STANDARD.encode(&image_data)
-            } else {
-                String::new()
-            };
-
-            json!({
-                "content": example,
-                "image_base64": image_base64,
-            })
-        })
-        .collect();
-
-    let tags = internal_fn.tags();
-    let module = tags
-        .first()
-        .map(|s| &**s)
-        .map(|m| format!("std::{m}"))
-        .unwrap_or("std".to_owned());
-
-    let data = json!({
-        "name": fn_name,
-        "module": module,
-        "summary": internal_fn.summary(),
-        "description": internal_fn.description(),
-        "deprecated": internal_fn.deprecated(),
-        "fn_signature": internal_fn.fn_signature(true),
-        "examples": examples,
-        "args": internal_fn.args(false).iter().map(|arg| {
-            json!({
-                "name": arg.name,
-                "type_": rename_type(&arg.type_),
-                "description": arg.description(Some(kcl_std)),
-                "required": arg.required,
-            })
-        }).collect::<Vec<_>>(),
-        "return_value": internal_fn.return_value(false).map(|ret| {
-            json!({
-                "type_": rename_type(&ret.type_),
-                "description": ret.description(Some(kcl_std)),
-            })
-        }),
-    });
-
-    let mut output = hbs.render("function", &data)?;
-    // Fix the links to the types.
-    output = cleanup_types(&output);
-
-    expectorate::assert_contents(format!("../../docs/kcl-std/{}.md", fn_name), &output);
-
-    Ok(())
-}
-
-fn cleanup_types(input: &str) -> String {
+fn cleanup_types(input: &str, kcl_std: &ModData) -> String {
     #[derive(Copy, Clone, Eq, PartialEq, Debug)]
     enum State {
         Text,
@@ -550,7 +401,7 @@ fn cleanup_types(input: &str) -> String {
                 if code_type.starts_with(' ') {
                     code.push(' ');
                 }
-                code.push_str(&cleanup_type_string(code_type.trim(), false));
+                code.push_str(&cleanup_type_string(code_type.trim(), false, kcl_std));
                 if code_type.ends_with(' ') {
                     code.push(' ');
                 }
@@ -586,7 +437,7 @@ fn cleanup_types(input: &str) -> String {
                     }
                     ticks = 0;
                 } else if state == State::Text && ticks == 2 && !code.is_empty() {
-                    output.push_str(&cleanup_type_string(&code, true));
+                    output.push_str(&cleanup_type_string(&code, true, kcl_std));
                     code = String::new();
                     ticks = 0;
                 } else if state == State::CodeBlock {
@@ -631,14 +482,12 @@ fn cleanup_types(input: &str) -> String {
     output
 }
 
-fn cleanup_type_string(input: &str, fmt_for_text: bool) -> String {
+fn cleanup_type_string(input: &str, fmt_for_text: bool, kcl_std: &ModData) -> String {
     assert!(
         !(input.starts_with('[') && input.ends_with(']') && input.contains('|')),
         "Arrays of unions are not supported"
     );
 
-    let input = rename_type(input);
-
     let tys: Vec<_> = input
         .split('|')
         .map(|ty| {
@@ -676,9 +525,7 @@ fn cleanup_type_string(input: &str, fmt_for_text: bool) -> String {
                 format!("[{prefix}{ty}{suffix}](/docs/kcl-std/types/std-types-number)")
             } else if fmt_for_text && ty.starts_with("fn") {
                 format!("[{prefix}{ty}{suffix}](/docs/kcl-std/types/std-types-fn)")
-            } else if fmt_for_text && SPECIAL_TYPES.contains(&ty) {
-                format!("[{prefix}{ty}{suffix}](/docs/kcl-lang/types#{ty})")
-            } else if fmt_for_text && DECLARED_TYPES.contains(&ty) {
+            } else if fmt_for_text && matches!(kcl_std.find_by_name(ty), Some(DocData::Ty(_))) {
                 format!("[{prefix}{ty}{suffix}](/docs/kcl-std/types/std-types-{ty})")
             } else {
                 format!("{prefix}{ty}{suffix}")
@@ -689,73 +536,22 @@ fn cleanup_type_string(input: &str, fmt_for_text: bool) -> String {
     tys.join(if fmt_for_text { " or " } else { " | " })
 }
 
-fn clean_function_name(name: &str) -> String {
-    // Convert from camel case to snake case.
-    let mut fn_name = name.to_case(convert_case::Case::Snake);
-    // Clean the fn name.
-    if fn_name.starts_with("last_seg_") {
-        fn_name = fn_name.replace("last_seg_", "last_segment_");
-    } else if fn_name.contains("_2_d") {
-        fn_name = fn_name.replace("_2_d", "_2d");
-    } else if fn_name.contains("_3_d") {
-        fn_name = fn_name.replace("_3_d", "_3d");
-    } else if fn_name == "seg_ang" {
-        fn_name = "segment_angle".to_string();
-    } else if fn_name == "seg_len" {
-        fn_name = "segment_length".to_string();
-    } else if fn_name.starts_with("seg_") {
-        fn_name = fn_name.replace("seg_", "segment_");
-    }
-
-    fn_name
-}
-
 #[test]
 fn test_generate_stdlib_markdown_docs() {
-    let stdlib = StdLib::new();
-    let combined = stdlib.combined();
     let kcl_std = crate::docs::kcl_doc::walk_prelude();
 
     // Generate the index which is the table of contents.
-    generate_index(&combined, &kcl_std).unwrap();
-
-    for key in combined.keys().sorted() {
-        let internal_fn = combined.get(key).unwrap();
-        generate_function(internal_fn.clone(), &kcl_std).unwrap();
-    }
+    generate_index(&kcl_std).unwrap();
 
     for d in kcl_std.all_docs() {
         match d {
             DocData::Fn(f) => generate_function_from_kcl(f, d.file_name(), d.example_name(), &kcl_std).unwrap(),
             DocData::Const(c) => generate_const_from_kcl(c, d.file_name(), d.example_name()).unwrap(),
-            DocData::Ty(t) => generate_type_from_kcl(t, d.file_name(), d.example_name()).unwrap(),
-            DocData::Mod(m) => generate_mod_from_kcl(m, d.file_name(), &combined).unwrap(),
+            DocData::Ty(t) => generate_type_from_kcl(t, d.file_name(), d.example_name(), &kcl_std).unwrap(),
+            DocData::Mod(m) => generate_mod_from_kcl(m, d.file_name()).unwrap(),
         }
     }
-    generate_mod_from_kcl(&kcl_std, "modules/std".to_owned(), &combined).unwrap();
-}
-
-#[test]
-fn test_generate_stdlib_json_schema() {
-    // If this test fails and you've modified the AST or something else which affects the json repr
-    // of stdlib functions, you should rerun the test with `EXPECTORATE=overwrite` to create new
-    // test data, then check `/docs/kcl-std/std.json` to ensure the changes are expected.
-    // Alternatively, run `just redo-kcl-stdlib-docs` (make sure to have just installed).
-    let stdlib = StdLib::new();
-    let combined = stdlib.combined();
-
-    let json_data: Vec<_> = combined
-        .keys()
-        .sorted()
-        .map(|key| {
-            let internal_fn = combined.get(key).unwrap();
-            internal_fn.to_json().unwrap()
-        })
-        .collect();
-    expectorate::assert_contents(
-        "../../docs/kcl-std/std.json",
-        &serde_json::to_string_pretty(&json_data).unwrap(),
-    );
+    generate_mod_from_kcl(&kcl_std, "modules/std".to_owned()).unwrap();
 }
 
 #[tokio::test(flavor = "multi_thread")]

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

@@ -302,6 +302,7 @@ impl DocData {
         }
     }
 
+    #[allow(dead_code)]
     pub(super) fn summary(&self) -> Option<&String> {
         match self {
             DocData::Fn(f) => f.summary.as_ref(),
@@ -462,6 +463,7 @@ impl ModData {
         }
     }
 
+    #[allow(dead_code)]
     pub fn find_by_name(&self, name: &str) -> Option<&DocData> {
         if let Some(result) = self
             .children
@@ -812,6 +814,7 @@ impl ArgData {
             return Some((index + n - 1, snippet));
         }
         match self.ty.as_deref() {
+            Some("Sketch") if self.kind == ArgKind::Special => None,
             Some(s) if s.starts_with("number") => Some((index, format!(r#"{label}${{{}:10}}"#, index))),
             Some("Point2d") => Some((index + 1, format!(r#"{label}[${{{}:0}}, ${{{}:0}}]"#, index, index + 1))),
             Some("Point3d") => Some((
@@ -827,7 +830,7 @@ impl ArgData {
             Some("Sketch") | Some("Sketch | Helix") => Some((index, format!(r#"{label}${{{index}:sketch000}}"#))),
             Some("Edge") => Some((index, format!(r#"{label}${{{index}:tag_or_edge_fn}}"#))),
             Some("[Edge; 1+]") => Some((index, format!(r#"{label}[${{{index}:tag_or_edge_fn}}]"#))),
-            Some("Plane") => Some((index, format!(r#"{label}${{{}:XY}}"#, index))),
+            Some("Plane") | Some("Solid | Plane") => Some((index, format!(r#"{label}${{{}:XY}}"#, index))),
             Some("[tag; 2]") => Some((
                 index + 1,
                 format!(r#"{label}[${{{}:tag}}, ${{{}:tag}}]"#, index, index + 1),
@@ -989,7 +992,7 @@ trait ApplyMeta {
         }
 
         let mut summary = None;
-        let mut description = None;
+        let mut description: Option<String> = None;
         let mut example: Option<(String, ExampleProperties)> = None;
         let mut examples = Vec::new();
         for l in comments.iter().filter(|l| l.starts_with("///")).map(|l| {
@@ -999,22 +1002,6 @@ trait ApplyMeta {
                 &l[3..]
             }
         }) {
-            if description.is_none() && summary.is_none() {
-                summary = Some(l.to_owned());
-                continue;
-            }
-            if description.is_none() {
-                if l.is_empty() {
-                    description = Some(String::new());
-                } else {
-                    description = summary;
-                    summary = None;
-                    let d = description.as_mut().unwrap();
-                    d.push('\n');
-                    d.push_str(l);
-                }
-                continue;
-            }
             #[allow(clippy::manual_strip)]
             if l.starts_with("```") {
                 if let Some((e, p)) = example {
@@ -1050,12 +1037,36 @@ trait ApplyMeta {
                     continue;
                 }
             }
+
+            // An empty line outside of an example. This either starts the description (with or
+            // without a summary) or adds a blank line to the description.
+            if l.is_empty() {
+                match &mut description {
+                    Some(d) => {
+                        d.push('\n');
+                    }
+                    None => description = Some(String::new()),
+                }
+                continue;
+            }
+
+            // Our first line, start the summary.
+            if description.is_none() && summary.is_none() {
+                summary = Some(l.to_owned());
+                continue;
+            }
+
+            // Append the line to either the description or summary.
             match &mut description {
                 Some(d) => {
                     d.push_str(l);
                     d.push('\n');
                 }
-                None => unreachable!(),
+                None => {
+                    let s = summary.as_mut().unwrap();
+                    s.push(' ');
+                    s.push_str(l);
+                }
             }
         }
         assert!(example.is_none());

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

@@ -67,6 +67,7 @@ pub struct TcpRead {
 
 /// Occurs when client couldn't read from the WebSocket to the engine.
 // #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub enum WebSocketReadError {
     /// Could not read a message due to WebSocket errors.
     Read(tokio_tungstenite::tungstenite::Error),
@@ -206,7 +207,7 @@ impl EngineConnection {
     async fn inner_send_to_engine(request: WebSocketRequest, tcp_write: &mut WebSocketTcpWrite) -> Result<()> {
         let msg = serde_json::to_string(&request).map_err(|e| anyhow!("could not serialize json: {e}"))?;
         tcp_write
-            .send(WsMsg::Text(msg))
+            .send(WsMsg::Text(msg.into()))
             .await
             .map_err(|e| anyhow!("could not send json over websocket: {e}"))?;
         Ok(())
@@ -216,19 +217,17 @@ impl EngineConnection {
     async fn inner_send_to_engine_binary(request: WebSocketRequest, tcp_write: &mut WebSocketTcpWrite) -> Result<()> {
         let msg = bson::to_vec(&request).map_err(|e| anyhow!("could not serialize bson: {e}"))?;
         tcp_write
-            .send(WsMsg::Binary(msg))
+            .send(WsMsg::Binary(msg.into()))
             .await
             .map_err(|e| anyhow!("could not send json over websocket: {e}"))?;
         Ok(())
     }
 
     pub async fn new(ws: reqwest::Upgraded) -> Result<EngineConnection> {
-        let wsconfig = tokio_tungstenite::tungstenite::protocol::WebSocketConfig {
+        let wsconfig = tokio_tungstenite::tungstenite::protocol::WebSocketConfig::default()
             // 4294967296 bytes, which is around 4.2 GB.
-            max_message_size: Some(usize::MAX),
-            max_frame_size: Some(usize::MAX),
-            ..Default::default()
-        };
+            .max_message_size(Some(usize::MAX))
+            .max_frame_size(Some(usize::MAX));
 
         let ws_stream = tokio_tungstenite::WebSocketStream::from_raw_socket(
             ws,

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

@@ -80,12 +80,12 @@ impl ResponseContext {
     }
 
     // Add a response to the context.
-    pub async fn send_response(&self, data: js_sys::Uint8Array) -> Result<(), JsValue> {
+    pub async fn send_response(&self, data: js_sys::Uint8Array) {
         let ws_result: WebSocketResponse = match bson::from_slice(&data.to_vec()) {
             Ok(res) => res,
             Err(_) => {
                 // We don't care about the error if we can't parse it.
-                return Ok(());
+                return;
             }
         };
 
@@ -96,13 +96,11 @@ impl ResponseContext {
 
         let Some(id) = id else {
             // We only care if we have an id.
-            return Ok(());
+            return;
         };
 
         // Add this response to our responses.
         self.add(id, ws_result.clone()).await;
-
-        Ok(())
     }
 }
 

rust/kcl-lib/src/errors.rs

@@ -565,30 +565,6 @@ impl KclError {
         new
     }
 
-    pub(crate) fn set_last_backtrace_fn_name(&self, last_fn_name: Option<String>) -> Self {
-        let mut new = self.clone();
-        match &mut new {
-            KclError::Lexical { details: e }
-            | KclError::Syntax { details: e }
-            | KclError::Semantic { details: e }
-            | KclError::ImportCycle { details: e }
-            | KclError::Type { details: e }
-            | KclError::Io { details: e }
-            | KclError::Unexpected { details: e }
-            | KclError::ValueAlreadyDefined { details: e }
-            | KclError::UndefinedValue { details: e, .. }
-            | KclError::InvalidExpression { details: e }
-            | KclError::Engine { details: e }
-            | KclError::Internal { details: e } => {
-                if let Some(item) = e.backtrace.last_mut() {
-                    item.fn_name = last_fn_name;
-                }
-            }
-        }
-
-        new
-    }
-
     pub(crate) fn add_unwind_location(&self, last_fn_name: Option<String>, source_range: SourceRange) -> Self {
         let mut new = self.clone();
         match &mut new {

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

@@ -676,6 +676,7 @@ impl EdgeCut {
 #[serde(rename_all = "camelCase")]
 pub struct ArtifactGraph {
     map: IndexMap<ArtifactId, Artifact>,
+    pub(super) item_count: usize,
 }
 
 impl ArtifactGraph {
@@ -711,10 +712,10 @@ pub(super) fn build_artifact_graph(
     artifact_commands: &[ArtifactCommand],
     responses: &IndexMap<Uuid, WebSocketResponse>,
     ast: &Node<Program>,
-    cached_body_items: usize,
     exec_artifacts: &mut IndexMap<ArtifactId, Artifact>,
     initial_graph: ArtifactGraph,
 ) -> Result<ArtifactGraph, KclError> {
+    let item_count = initial_graph.item_count;
     let mut map = initial_graph.into_map();
 
     let mut path_to_plane_id_map = FnvHashMap::default();
@@ -725,7 +726,7 @@ pub(super) fn build_artifact_graph(
     for exec_artifact in exec_artifacts.values_mut() {
         // Note: We only have access to the new AST. So if these artifacts
         // somehow came from cached AST, this won't fill in anything.
-        fill_in_node_paths(exec_artifact, ast, cached_body_items);
+        fill_in_node_paths(exec_artifact, ast, item_count);
     }
 
     for artifact_command in artifact_commands {
@@ -752,7 +753,7 @@ pub(super) fn build_artifact_graph(
             &flattened_responses,
             &path_to_plane_id_map,
             ast,
-            cached_body_items,
+            item_count,
             exec_artifacts,
         )?;
         for artifact in artifact_updates {
@@ -765,7 +766,10 @@ pub(super) fn build_artifact_graph(
         merge_artifact_into_map(&mut map, exec_artifact.clone());
     }
 
-    Ok(ArtifactGraph { map })
+    Ok(ArtifactGraph {
+        map,
+        item_count: item_count + ast.body.len(),
+    })
 }
 
 /// These may have been created with placeholder `CodeRef`s because we didn't

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

@@ -6,25 +6,31 @@ use itertools::{EitherOrBoth, Itertools};
 use tokio::sync::RwLock;
 
 use crate::{
-    execution::{annotations, memory::Stack, state::ModuleInfoMap, EnvironmentRef, ExecState, ExecutorSettings},
+    execution::{
+        annotations,
+        memory::Stack,
+        state::{self as exec_state, ModuleInfoMap},
+        EnvironmentRef, ExecutorSettings,
+    },
     parsing::ast::types::{Annotation, Node, Program},
     walk::Node as WalkNode,
+    ExecOutcome, ExecutorContext,
 };
 
 lazy_static::lazy_static! {
     /// A static mutable lock for updating the last successful execution state for the cache.
-    static ref OLD_AST: Arc<RwLock<Option<OldAstState>>> = Default::default();
+    static ref OLD_AST: Arc<RwLock<Option<GlobalState>>> = Default::default();
     // The last successful run's memory. Not cleared after an unssuccessful run.
     static ref PREV_MEMORY: Arc<RwLock<Option<(Stack, ModuleInfoMap)>>> = Default::default();
 }
 
 /// Read the old ast memory from the lock.
-pub(crate) async fn read_old_ast() -> Option<OldAstState> {
+pub(super) async fn read_old_ast() -> Option<GlobalState> {
     let old_ast = OLD_AST.read().await;
     old_ast.clone()
 }
 
-pub(super) async fn write_old_ast(old_state: OldAstState) {
+pub(super) async fn write_old_ast(old_state: GlobalState) {
     let mut old_ast = OLD_AST.write().await;
     *old_ast = Some(old_state);
 }
@@ -34,7 +40,7 @@ pub(crate) async fn read_old_memory() -> Option<(Stack, ModuleInfoMap)> {
     old_mem.clone()
 }
 
-pub(super) async fn write_old_memory(mem: (Stack, ModuleInfoMap)) {
+pub(crate) async fn write_old_memory(mem: (Stack, ModuleInfoMap)) {
     let mut old_mem = PREV_MEMORY.write().await;
     *old_mem = Some(mem);
 }
@@ -56,16 +62,73 @@ pub struct CacheInformation<'a> {
     pub settings: &'a ExecutorSettings,
 }
 
-/// The old ast and program memory.
+/// The cached state of the whole program.
 #[derive(Debug, Clone)]
-pub struct OldAstState {
-    /// The ast.
-    pub ast: Node<Program>,
+pub(super) struct GlobalState {
+    pub(super) main: ModuleState,
     /// The exec state.
-    pub exec_state: ExecState,
+    pub(super) exec_state: exec_state::GlobalState,
     /// The last settings used for execution.
-    pub settings: crate::execution::ExecutorSettings,
-    pub result_env: EnvironmentRef,
+    pub(super) settings: ExecutorSettings,
+}
+
+impl GlobalState {
+    pub fn new(
+        state: exec_state::ExecState,
+        settings: ExecutorSettings,
+        ast: Node<Program>,
+        result_env: EnvironmentRef,
+    ) -> Self {
+        Self {
+            main: ModuleState {
+                ast,
+                exec_state: state.mod_local,
+                result_env,
+            },
+            exec_state: state.global,
+            settings,
+        }
+    }
+
+    pub fn with_settings(mut self, settings: ExecutorSettings) -> GlobalState {
+        self.settings = settings;
+        self
+    }
+
+    pub fn reconstitute_exec_state(&self) -> exec_state::ExecState {
+        exec_state::ExecState {
+            global: self.exec_state.clone(),
+            mod_local: self.main.exec_state.clone(),
+        }
+    }
+
+    pub async fn into_exec_outcome(self, ctx: &ExecutorContext) -> ExecOutcome {
+        // Fields are opt-in so that we don't accidentally leak private internal
+        // state when we add more to ExecState.
+        ExecOutcome {
+            variables: self.main.exec_state.variables(self.main.result_env),
+            filenames: self.exec_state.filenames(),
+            #[cfg(feature = "artifact-graph")]
+            operations: self.exec_state.artifacts.operations,
+            #[cfg(feature = "artifact-graph")]
+            artifact_commands: self.exec_state.artifacts.commands,
+            #[cfg(feature = "artifact-graph")]
+            artifact_graph: self.exec_state.artifacts.graph,
+            errors: self.exec_state.errors,
+            default_planes: ctx.engine.get_default_planes().read().await.clone(),
+        }
+    }
+}
+
+/// Per-module cached state
+#[derive(Debug, Clone)]
+pub(super) struct ModuleState {
+    /// The AST of the module.
+    pub(super) ast: Node<Program>,
+    /// The ExecState of the module.
+    pub(super) exec_state: exec_state::ModuleState,
+    /// The memory env for the module.
+    pub(super) result_env: EnvironmentRef,
 }
 
 /// The result of a cache check.
@@ -79,9 +142,6 @@ pub(super) enum CacheResult {
         reapply_settings: bool,
         /// The program that needs to be executed.
         program: Node<Program>,
-        /// The number of body items that were cached and omitted from the
-        /// program that needs to be executed. Used to compute [`crate::NodePath`].
-        cached_body_items: usize,
     },
     /// Check only the imports, and not the main program.
     /// Before sending this we already checked the main program and it is the same.
@@ -146,7 +206,6 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
         // We know they have the same imports because the ast is the same.
         // If we have no imports, we can skip this.
         if !old.ast.has_import_statements() {
-            println!("No imports, no need to check.");
             return CacheResult::NoAction(reapply_settings);
         }
 
@@ -194,7 +253,6 @@ pub(super) async fn get_changed_program(old: CacheInformation<'_>, new: CacheInf
             clear_scene: true,
             reapply_settings: true,
             program: new.ast.clone(),
-            cached_body_items: 0,
         };
     }
 
@@ -223,7 +281,6 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>,
             clear_scene: true,
             reapply_settings,
             program: new_ast,
-            cached_body_items: 0,
         };
     }
 
@@ -244,7 +301,6 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>,
                 clear_scene: true,
                 reapply_settings,
                 program: new_ast,
-                cached_body_items: 0,
             }
         }
         std::cmp::Ordering::Greater => {
@@ -261,7 +317,6 @@ fn generate_changed_program(old_ast: Node<Program>, mut new_ast: Node<Program>,
                 clear_scene: false,
                 reapply_settings,
                 program: new_ast,
-                cached_body_items: old_ast.body.len(),
             }
         }
         std::cmp::Ordering::Equal => {
@@ -600,7 +655,6 @@ startSketchOn(XY)
                 clear_scene: true,
                 reapply_settings: true,
                 program: new_program.ast,
-                cached_body_items: 0,
             }
         );
     }
@@ -639,7 +693,6 @@ startSketchOn(XY)
                 clear_scene: true,
                 reapply_settings: true,
                 program: new_program.ast,
-                cached_body_items: 0,
             }
         );
     }

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

@@ -1,13 +1,12 @@
 use indexmap::IndexMap;
-use schemars::JsonSchema;
 use serde::Serialize;
 
 use super::{types::NumericType, ArtifactId, KclValue};
-use crate::{ModuleId, SourceRange};
+use crate::{ModuleId, NodePath, SourceRange};
 
 /// A CAD modeling operation for display in the feature tree, AKA operations
 /// timeline.
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 pub enum Operation {
@@ -18,6 +17,8 @@ pub enum Operation {
         unlabeled_arg: Option<OpArg>,
         /// The labeled keyword arguments to the function.
         labeled_args: IndexMap<String, OpArg>,
+        /// The node path of the operation in the source code.
+        node_path: NodePath,
         /// The source range of the operation in the source code.
         source_range: SourceRange,
         /// True if the operation resulted in an error.
@@ -28,6 +29,8 @@ pub enum Operation {
     GroupBegin {
         /// The details of the group.
         group: Group,
+        /// The node path of the operation in the source code.
+        node_path: NodePath,
         /// The source range of the operation in the source code.
         source_range: SourceRange,
     },
@@ -64,7 +67,7 @@ impl Operation {
     }
 }
 
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 #[expect(clippy::large_enum_variant)]
@@ -95,7 +98,7 @@ pub enum Group {
 }
 
 /// An argument to a CAD modeling operation.
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct OpArg {
@@ -119,7 +122,7 @@ fn is_false(b: &bool) -> bool {
 
 /// A KCL value used in Operations.  `ArtifactId`s are used to refer to the
 /// actual scene objects.  Any data not needed in the UI may be omitted.
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(tag = "type")]
 pub enum OpKclValue {
@@ -177,21 +180,21 @@ pub enum OpKclValue {
 
 pub type OpKclObjectFields = IndexMap<String, OpKclValue>;
 
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct OpSketch {
     artifact_id: ArtifactId,
 }
 
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct OpSolid {
     artifact_id: ArtifactId,
 }
 
-#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS)]
 #[ts(export_to = "Operation.ts")]
 #[serde(rename_all = "camelCase")]
 pub struct OpHelix {

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

@@ -19,8 +19,8 @@ use crate::{
     parsing::ast::types::{
         Annotation, ArrayExpression, ArrayRangeExpression, AscribedExpression, BinaryExpression, BinaryOperator,
         BinaryPart, BodyItem, Expr, IfExpression, ImportPath, ImportSelector, ItemVisibility, LiteralIdentifier,
-        LiteralValue, MemberExpression, MemberObject, Name, Node, NodeRef, ObjectExpression, PipeExpression, Program,
-        TagDeclarator, Type, UnaryExpression, UnaryOperator,
+        LiteralValue, MemberExpression, Name, Node, NodeRef, ObjectExpression, PipeExpression, Program, TagDeclarator,
+        Type, UnaryExpression, UnaryOperator,
     },
     source_range::SourceRange,
     std::args::TyF64,
@@ -304,9 +304,11 @@ impl ExecutorContext {
 
                     let annotations = &variable_declaration.outer_attrs;
 
-                    // During the evaluation of the variable's LHS, set context that this is all happening inside a variable
+                    // During the evaluation of the variable's RHS, set context that this is all happening inside a variable
                     // declaration, for the given name. This helps improve user-facing error messages.
-                    exec_state.mod_local.being_declared = Some(variable_declaration.inner.name().to_owned());
+                    let lhs = variable_declaration.inner.name().to_owned();
+                    let prev_being_declared = exec_state.mod_local.being_declared.take();
+                    exec_state.mod_local.being_declared = Some(lhs);
                     let rhs_result = self
                         .execute_expr(
                             &variable_declaration.declaration.init,
@@ -317,7 +319,7 @@ impl ExecutorContext {
                         )
                         .await;
                     // Declaration over, so unset this context.
-                    exec_state.mod_local.being_declared = None;
+                    exec_state.mod_local.being_declared = prev_being_declared;
                     let rhs = rhs_result?;
 
                     exec_state
@@ -645,7 +647,12 @@ impl ExecutorContext {
             Expr::Literal(literal) => KclValue::from_literal((**literal).clone(), exec_state),
             Expr::TagDeclarator(tag) => tag.execute(exec_state).await?,
             Expr::Name(name) => {
-                let value = name.get_result(exec_state, self).await?.clone();
+                let being_declared = exec_state.mod_local.being_declared.clone();
+                let value = name
+                    .get_result(exec_state, self)
+                    .await
+                    .map_err(|e| var_in_own_ref_err(e, &being_declared))?
+                    .clone();
                 if let KclValue::Module { value: module_id, meta } = value {
                     self.exec_module_for_result(
                         module_id,
@@ -732,7 +739,7 @@ impl ExecutorContext {
             Expr::ArrayExpression(array_expression) => array_expression.execute(exec_state, self).await?,
             Expr::ArrayRangeExpression(range_expression) => range_expression.execute(exec_state, self).await?,
             Expr::ObjectExpression(object_expression) => object_expression.execute(exec_state, self).await?,
-            Expr::MemberExpression(member_expression) => member_expression.get_result(exec_state)?,
+            Expr::MemberExpression(member_expression) => member_expression.get_result(exec_state, self).await?,
             Expr::UnaryExpression(unary_expression) => unary_expression.get_result(exec_state, self).await?,
             Expr::IfExpression(expr) => expr.get_result(exec_state, self).await?,
             Expr::LabelledExpression(expr) => {
@@ -751,6 +758,24 @@ impl ExecutorContext {
     }
 }
 
+/// If the error is about an undefined name, and that name matches the name being defined,
+/// make the error message more specific.
+fn var_in_own_ref_err(e: KclError, being_declared: &Option<String>) -> KclError {
+    let KclError::UndefinedValue { name, mut details } = e else {
+        return e;
+    };
+    // TODO after June 26th: replace this with a let-chain,
+    // which will be available in Rust 1.88
+    // https://rust-lang.github.io/rfcs/2497-if-let-chains.html
+    match (&being_declared, &name) {
+        (Some(name0), Some(name1)) if name0 == name1 => {
+            details.message = format!("You can't use `{name0}` because you're currently trying to define it. Use a different variable here instead.");
+        }
+        _ => {}
+    }
+    KclError::UndefinedValue { details, name }
+}
+
 impl Node<AscribedExpression> {
     #[async_recursion]
     pub async fn get_result(&self, exec_state: &mut ExecState, ctx: &ExecutorContext) -> Result<KclValue, KclError> {
@@ -800,7 +825,7 @@ impl BinaryPart {
             BinaryPart::BinaryExpression(binary_expression) => binary_expression.get_result(exec_state, ctx).await,
             BinaryPart::CallExpressionKw(call_expression) => call_expression.execute(exec_state, ctx).await,
             BinaryPart::UnaryExpression(unary_expression) => unary_expression.get_result(exec_state, ctx).await,
-            BinaryPart::MemberExpression(member_expression) => member_expression.get_result(exec_state),
+            BinaryPart::MemberExpression(member_expression) => member_expression.get_result(exec_state, ctx).await,
             BinaryPart::IfExpression(e) => e.get_result(exec_state, ctx).await,
             BinaryPart::AscribedExpression(e) => e.get_result(exec_state, ctx).await,
         }
@@ -812,6 +837,17 @@ impl Node<Name> {
         &self,
         exec_state: &'a mut ExecState,
         ctx: &ExecutorContext,
+    ) -> Result<&'a KclValue, KclError> {
+        let being_declared = exec_state.mod_local.being_declared.clone();
+        self.get_result_inner(exec_state, ctx)
+            .await
+            .map_err(|e| var_in_own_ref_err(e, &being_declared))
+    }
+
+    async fn get_result_inner<'a>(
+        &self,
+        exec_state: &'a mut ExecState,
+        ctx: &ExecutorContext,
     ) -> Result<&'a KclValue, KclError> {
         if self.abs_path {
             return Err(KclError::new_semantic(KclErrorDetails::new(
@@ -906,16 +942,14 @@ impl Node<Name> {
 }
 
 impl Node<MemberExpression> {
-    fn get_result(&self, exec_state: &mut ExecState) -> Result<KclValue, KclError> {
+    async fn get_result(&self, exec_state: &mut ExecState, ctx: &ExecutorContext) -> Result<KclValue, KclError> {
         let property = Property::try_from(self.computed, self.property.clone(), exec_state, self.into())?;
-        let object = match &self.object {
-            // TODO: Don't use recursion here, use a loop.
-            MemberObject::MemberExpression(member_expr) => member_expr.get_result(exec_state)?,
-            MemberObject::Identifier(identifier) => {
-                let value = exec_state.stack().get(&identifier.name, identifier.into())?;
-                value.clone()
-            }
+        let meta = Metadata {
+            source_range: SourceRange::from(self),
         };
+        let object = ctx
+            .execute_expr(&self.object, exec_state, &meta, &[], StatementKind::Expression)
+            .await?;
 
         // Check the property and object match -- e.g. ints for arrays, strs for objects.
         match (object, property, self.computed) {
@@ -1327,7 +1361,7 @@ pub(crate) async fn execute_pipe_body(
     // Now that we've evaluated the first child expression in the pipeline, following child expressions
     // should use the previous child expression for %.
     // This means there's no more need for the previous pipe_value from the parent AST node above this one.
-    let previous_pipe_value = std::mem::replace(&mut exec_state.mod_local.pipe_value, Some(output));
+    let previous_pipe_value = exec_state.mod_local.pipe_value.replace(output);
     // Evaluate remaining elements.
     let result = inner_execute_pipe_body(exec_state, body, ctx).await;
     // Restore the previous pipe value.
@@ -1877,7 +1911,6 @@ d = b + c
                 project_directory: Some(crate::TypedPath(tmpdir.path().into())),
                 ..Default::default()
             },
-            stdlib: Arc::new(crate::std::StdLib::new()),
             context_type: ContextType::Mock,
         };
         let mut exec_state = ExecState::new(&exec_ctxt);

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

@@ -2,7 +2,6 @@ use async_recursion::async_recursion;
 use indexmap::IndexMap;
 
 use crate::{
-    docs::StdLibFn,
     errors::{KclError, KclErrorDetails},
     execution::{
         cad_op::{Group, OpArg, OpKclValue, Operation},
@@ -15,7 +14,7 @@ use crate::{
     parsing::ast::types::{CallExpressionKw, DefaultParamVal, FunctionExpression, Node, Program, Type},
     source_range::SourceRange,
     std::StdFn,
-    CompilationError,
+    CompilationError, NodePath,
 };
 
 #[derive(Debug, Clone)]
@@ -184,40 +183,6 @@ impl<'a> From<&'a FunctionSource> for FunctionDefinition<'a> {
     }
 }
 
-impl From<&dyn StdLibFn> for FunctionDefinition<'static> {
-    fn from(value: &dyn StdLibFn) -> Self {
-        let mut input_arg = None;
-        let mut named_args = IndexMap::new();
-        for a in value.args(false) {
-            if !a.label_required {
-                input_arg = Some((a.name.clone(), None));
-                continue;
-            }
-
-            named_args.insert(
-                a.name.clone(),
-                (
-                    if a.required {
-                        None
-                    } else {
-                        Some(DefaultParamVal::none())
-                    },
-                    None,
-                ),
-            );
-        }
-        FunctionDefinition {
-            input_arg,
-            named_args,
-            return_type: None,
-            deprecated: value.deprecated(),
-            include_in_feature_tree: value.feature_tree_operation(),
-            is_std: true,
-            body: FunctionBody::Rust(value.std_lib_fn()),
-        }
-    }
-}
-
 impl Node<CallExpressionKw> {
     #[async_recursion]
     pub async fn execute(&self, exec_state: &mut ExecState, ctx: &ExecutorContext) -> Result<KclValue, KclError> {
@@ -274,62 +239,44 @@ impl Node<CallExpressionKw> {
             exec_state.pipe_value().map(|v| Arg::new(v.clone(), callsite)),
         );
 
-        match ctx.stdlib.get_rust_function(fn_name) {
-            Some(func) => {
-                let def: FunctionDefinition = (&*func).into();
-                // All std lib functions return a value, so the unwrap is safe.
-                def.call_kw(Some(func.name()), exec_state, ctx, args, callsite)
-                    .await
-                    .map(Option::unwrap)
-                    .map_err(|e| {
-                        // This is used for the backtrace display.  We don't add
-                        // another location the way we do for user-defined
-                        // functions because the error uses the Args, which
-                        // already points here.
-                        e.set_last_backtrace_fn_name(Some(func.name()))
-                    })
-            }
-            None => {
-                // Clone the function so that we can use a mutable reference to
-                // exec_state.
-                let func = fn_name.get_result(exec_state, ctx).await?.clone();
+        // Clone the function so that we can use a mutable reference to
+        // exec_state.
+        let func = fn_name.get_result(exec_state, ctx).await?.clone();
 
-                let Some(fn_src) = func.as_function() else {
-                    return Err(KclError::new_semantic(KclErrorDetails::new(
-                        "cannot call this because it isn't a function".to_string(),
-                        vec![callsite],
-                    )));
-                };
+        let Some(fn_src) = func.as_function() else {
+            return Err(KclError::new_semantic(KclErrorDetails::new(
+                "cannot call this because it isn't a function".to_string(),
+                vec![callsite],
+            )));
+        };
 
-                let return_value = fn_src
-                    .call_kw(Some(fn_name.to_string()), exec_state, ctx, args, callsite)
-                    .await
-                    .map_err(|e| {
-                        // Add the call expression to the source ranges.
-                        //
-                        // TODO: Use the name that the function was defined
-                        // with, not the identifier it was used with.
-                        e.add_unwind_location(Some(fn_name.name.name.clone()), callsite)
-                    })?;
+        let return_value = fn_src
+            .call_kw(Some(fn_name.to_string()), exec_state, ctx, args, callsite)
+            .await
+            .map_err(|e| {
+                // Add the call expression to the source ranges.
+                //
+                // TODO: Use the name that the function was defined
+                // with, not the identifier it was used with.
+                e.add_unwind_location(Some(fn_name.name.name.clone()), callsite)
+            })?;
 
-                let result = return_value.ok_or_else(move || {
-                    let mut source_ranges: Vec<SourceRange> = vec![callsite];
-                    // We want to send the source range of the original function.
-                    if let KclValue::Function { meta, .. } = func {
-                        source_ranges = meta.iter().map(|m| m.source_range).collect();
-                    };
-                    KclError::new_undefined_value(
-                        KclErrorDetails::new(
-                            format!("Result of user-defined function {} is undefined", fn_name),
-                            source_ranges,
-                        ),
-                        None,
-                    )
-                })?;
+        let result = return_value.ok_or_else(move || {
+            let mut source_ranges: Vec<SourceRange> = vec![callsite];
+            // We want to send the source range of the original function.
+            if let KclValue::Function { meta, .. } = func {
+                source_ranges = meta.iter().map(|m| m.source_range).collect();
+            };
+            KclError::new_undefined_value(
+                KclErrorDetails::new(
+                    format!("Result of user-defined function {} is undefined", fn_name),
+                    source_ranges,
+                ),
+                None,
+            )
+        })?;
 
-                Ok(result)
-            }
-        }
+        Ok(result)
     }
 }
 
@@ -375,6 +322,7 @@ impl FunctionDefinition<'_> {
                         .unlabeled_kw_arg_unconverted()
                         .map(|arg| OpArg::new(OpKclValue::from(&arg.value), arg.source_range)),
                     labeled_args: op_labeled_args,
+                    node_path: NodePath::placeholder(),
                     source_range: callsite,
                     is_error: false,
                 })
@@ -390,6 +338,7 @@ impl FunctionDefinition<'_> {
                             .map(|arg| OpArg::new(OpKclValue::from(&arg.1.value), arg.1.source_range)),
                         labeled_args: op_labeled_args,
                     },
+                    node_path: NodePath::placeholder(),
                     source_range: callsite,
                 });
 
@@ -603,30 +552,33 @@ fn type_check_params_kw(
 
     for (label, arg) in &mut args.labeled {
         match fn_def.named_args.get(label) {
-            Some((_, ty)) => {
-                if let Some(ty) = ty {
-                    arg.value = arg
-                        .value
-                        .coerce(
-                            &RuntimeType::from_parsed(ty.clone(), exec_state, arg.source_range).map_err(|e| KclError::new_semantic(e.into()))?,
-                            true,
-                            exec_state,
-                        )
-                        .map_err(|e| {
-                            let mut message = format!(
-                                "{label} requires a value with type `{}`, but found {}",
-                                ty,
-                                arg.value.human_friendly_type(),
-                            );
-                            if let Some(ty) = e.explicit_coercion {
-                                // TODO if we have access to the AST for the argument we could choose which example to suggest.
-                                message = format!("{message}\n\nYou may need to add information about the type of the argument, for example:\n  using a numeric suffix: `42{ty}`\n  or using type ascription: `foo(): number({ty})`");
-                            }
-                            KclError::new_semantic(KclErrorDetails::new(
-                                message,
-                                vec![arg.source_range],
-                            ))
-                        })?;
+            Some((def, ty)) => {
+                // For optional args, passing None should be the same as not passing an arg.
+                if !(def.is_some() && matches!(arg.value, KclValue::KclNone { .. })) {
+                    if let Some(ty) = ty {
+                        arg.value = arg
+                            .value
+                            .coerce(
+                                &RuntimeType::from_parsed(ty.clone(), exec_state, arg.source_range).map_err(|e| KclError::new_semantic(e.into()))?,
+                                true,
+                                exec_state,
+                            )
+                            .map_err(|e| {
+                                let mut message = format!(
+                                    "{label} requires a value with type `{}`, but found {}",
+                                    ty,
+                                    arg.value.human_friendly_type(),
+                                );
+                                if let Some(ty) = e.explicit_coercion {
+                                    // TODO if we have access to the AST for the argument we could choose which example to suggest.
+                                    message = format!("{message}\n\nYou may need to add information about the type of the argument, for example:\n  using a numeric suffix: `42{ty}`\n  or using type ascription: `foo(): number({ty})`");
+                                }
+                                KclError::new_semantic(KclErrorDetails::new(
+                                    message,
+                                    vec![arg.source_range],
+                                ))
+                            })?;
+                    }
                 }
             }
             None => {
@@ -706,7 +658,7 @@ fn type_check_params_kw(
             exec_state.err(CompilationError::err(
                 arg.source_range,
                 format!(
-                    "{} expects an unlabeled first parameter (`@{name}`), but it is labelled in the call",
+                    "{} expects an unlabeled first argument (`@{name}`), but it is labelled in the call",
                     fn_name
                         .map(|n| format!("The function `{}`", n))
                         .unwrap_or_else(|| "This function".to_owned()),
@@ -940,7 +892,6 @@ mod test {
                     crate::engine::conn_mock::EngineConnection::new().await.unwrap(),
                 )),
                 fs: Arc::new(crate::fs::FileManager::new()),
-                stdlib: Arc::new(crate::std::StdLib::new()),
                 settings: Default::default(),
                 context_type: ContextType::Mock,
             };

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

@@ -24,6 +24,7 @@ type Point3D = kcmc::shared::Point3d<f64>;
 #[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
+#[allow(clippy::large_enum_variant)]
 pub enum Geometry {
     Sketch(Sketch),
     Solid(Solid),
@@ -52,6 +53,7 @@ impl Geometry {
 #[derive(Debug, Clone, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
+#[allow(clippy::large_enum_variant)]
 pub enum GeometryWithImportedGeometry {
     Sketch(Sketch),
     Solid(Solid),

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

@@ -31,7 +31,7 @@ pub(crate) type Universe = HashMap<String, DependencyInfo>;
 /// run concurrently. Each "stage" is blocking in this model, which will
 /// change in the future. Don't use this function widely, yet.
 #[allow(clippy::iter_over_hash_type)]
-pub fn import_graph(progs: &Universe, ctx: &ExecutorContext) -> Result<Vec<Vec<String>>, KclError> {
+pub(crate) fn import_graph(progs: &Universe, ctx: &ExecutorContext) -> Result<Vec<Vec<String>>, KclError> {
     let mut graph = Graph::new();
 
     for (name, (_, _, path, repr)) in progs.iter() {
@@ -120,7 +120,7 @@ fn topsort(all_modules: &[&str], graph: Graph) -> Result<Vec<Vec<String>>, KclEr
 
 type ImportDependencies = Vec<(String, AstNode<ImportStatement>, ModulePath)>;
 
-pub(crate) fn import_dependencies(
+fn import_dependencies(
     path: &ModulePath,
     repr: &ModuleRepr,
     ctx: &ExecutorContext,

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

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use anyhow::Result;
 #[cfg(feature = "artifact-graph")]
 pub use artifact::{Artifact, ArtifactCommand, ArtifactGraph, CodeRef, StartSketchOnFace, StartSketchOnPlane};
-use cache::OldAstState;
+use cache::GlobalState;
 pub use cache::{bust_cache, clear_mem_cache};
 #[cfg(feature = "artifact-graph")]
 pub use cad_op::{Group, Operation};
@@ -27,13 +27,12 @@ use serde::{Deserialize, Serialize};
 pub use state::{ExecState, MetaSettings};
 use uuid::Uuid;
 
-#[cfg(feature = "artifact-graph")]
-use crate::execution::artifact::build_artifact_graph;
 use crate::{
     engine::EngineManager,
     errors::{KclError, KclErrorDetails},
     execution::{
         cache::{CacheInformation, CacheResult},
+        import_graph::{Universe, UniverseMap},
         typed_path::TypedPath,
         types::{UnitAngle, UnitLen},
     },
@@ -41,8 +40,6 @@ use crate::{
     modules::{ModuleId, ModulePath, ModuleRepr},
     parsing::ast::types::{Expr, ImportPath, NodeRef},
     source_range::SourceRange,
-    std::StdLib,
-    walk::{Universe, UniverseMap},
     CompilationError, ExecError, KclErrorWithOutputs,
 };
 
@@ -56,6 +53,7 @@ pub mod fn_call;
 mod geometry;
 mod id_generator;
 mod import;
+mod import_graph;
 pub(crate) mod kcl_value;
 mod memory;
 mod state;
@@ -273,7 +271,6 @@ pub enum ContextType {
 pub struct ExecutorContext {
     pub engine: Arc<Box<dyn EngineManager>>,
     pub fs: Arc<FileManager>,
-    pub stdlib: Arc<StdLib>,
     pub settings: ExecutorSettings,
     pub context_type: ContextType,
 }
@@ -412,7 +409,6 @@ impl ExecutorContext {
         Ok(Self {
             engine,
             fs: Arc::new(FileManager::new()),
-            stdlib: Arc::new(StdLib::new()),
             settings,
             context_type: ContextType::Live,
         })
@@ -423,7 +419,6 @@ impl ExecutorContext {
         ExecutorContext {
             engine,
             fs,
-            stdlib: Arc::new(StdLib::new()),
             settings,
             context_type: ContextType::Live,
         }
@@ -436,7 +431,6 @@ impl ExecutorContext {
                 crate::engine::conn_mock::EngineConnection::new().await.unwrap(),
             )),
             fs: Arc::new(FileManager::new()),
-            stdlib: Arc::new(StdLib::new()),
             settings: settings.unwrap_or_default(),
             context_type: ContextType::Mock,
         }
@@ -447,7 +441,6 @@ impl ExecutorContext {
         ExecutorContext {
             engine,
             fs,
-            stdlib: Arc::new(StdLib::new()),
             settings,
             context_type: ContextType::Mock,
         }
@@ -458,7 +451,6 @@ impl ExecutorContext {
         ExecutorContext {
             engine,
             fs: Arc::new(FileManager::new()),
-            stdlib: Arc::new(StdLib::new()),
             settings: Default::default(),
             context_type: ContextType::MockCustomForwarded,
         }
@@ -575,7 +567,7 @@ impl ExecutorContext {
         // part of the scene).
         exec_state.mut_stack().push_new_env_for_scope();
 
-        let result = self.inner_run(&program, 0, &mut exec_state, true).await?;
+        let result = self.inner_run(&program, &mut exec_state, true).await?;
 
         // Restore any temporary variables, then save any newly created variables back to
         // memory in case another run wants to use them. Note this is just saved to the preserved
@@ -583,7 +575,7 @@ impl ExecutorContext {
 
         let mut mem = exec_state.stack().clone();
         let module_infos = exec_state.global.module_infos.clone();
-        let outcome = exec_state.to_mock_exec_outcome(result.0).await;
+        let outcome = exec_state.to_mock_exec_outcome(result.0, self).await;
 
         mem.squash_env(result.0);
         cache::write_old_memory((mem, module_infos)).await;
@@ -594,169 +586,176 @@ impl ExecutorContext {
     pub async fn run_with_caching(&self, program: crate::Program) -> Result<ExecOutcome, KclErrorWithOutputs> {
         assert!(!self.is_mock());
 
-        let (program, mut exec_state, preserve_mem, cached_body_items, imports_info) = if let Some(OldAstState {
-            ast: old_ast,
-            exec_state: mut old_state,
-            settings: old_settings,
-            result_env,
-        }) =
-            cache::read_old_ast().await
-        {
-            let old = CacheInformation {
-                ast: &old_ast,
-                settings: &old_settings,
-            };
-            let new = CacheInformation {
-                ast: &program.ast,
-                settings: &self.settings,
-            };
-
-            // Get the program that actually changed from the old and new information.
-            let (clear_scene, program, body_items, import_check_info) = match cache::get_changed_program(old, new).await
-            {
-                CacheResult::ReExecute {
-                    clear_scene,
-                    reapply_settings,
-                    program: changed_program,
-                    cached_body_items,
-                } => {
-                    if reapply_settings
-                        && self
-                            .engine
-                            .reapply_settings(&self.settings, Default::default(), old_state.id_generator())
-                            .await
-                            .is_err()
-                    {
-                        (true, program, cached_body_items, None)
-                    } else {
-                        (
-                            clear_scene,
-                            crate::Program {
-                                ast: changed_program,
-                                original_file_contents: program.original_file_contents,
-                            },
-                            cached_body_items,
-                            None,
-                        )
-                    }
-                }
-                CacheResult::CheckImportsOnly {
-                    reapply_settings,
-                    ast: changed_program,
-                } => {
-                    if reapply_settings
-                        && self
-                            .engine
-                            .reapply_settings(&self.settings, Default::default(), old_state.id_generator())
-                            .await
-                            .is_err()
-                    {
-                        (true, program, old_ast.body.len(), None)
-                    } else {
-                        // We need to check our imports to see if they changed.
-                        let mut new_exec_state = ExecState::new(self);
-                        let (new_universe, new_universe_map) = self.get_universe(&program, &mut new_exec_state).await?;
-                        let mut clear_scene = false;
-
-                        let mut keys = new_universe.keys().clone().collect::<Vec<_>>();
-                        keys.sort();
-                        for key in keys {
-                            let (_, id, _, _) = &new_universe[key];
-                            if let (Some(source0), Some(source1)) =
-                                (old_state.get_source(*id), new_exec_state.get_source(*id))
-                            {
-                                if source0.source != source1.source {
-                                    clear_scene = true;
-                                    break;
-                                }
-                            }
-                        }
-
-                        if !clear_scene {
-                            // Return early we don't need to clear the scene.
-                            let outcome = old_state.to_exec_outcome(result_env).await;
-                            return Ok(outcome);
-                        }
-
-                        (
-                            clear_scene,
-                            crate::Program {
-                                ast: changed_program,
-                                original_file_contents: program.original_file_contents,
-                            },
-                            old_ast.body.len(),
-                            // We only care about this if we are clearing the scene.
-                            if clear_scene {
-                                Some((new_universe, new_universe_map, new_exec_state))
-                            } else {
-                                None
-                            },
-                        )
-                    }
-                }
-                CacheResult::NoAction(true) => {
-                    if self
-                        .engine
-                        .reapply_settings(&self.settings, Default::default(), old_state.id_generator())
-                        .await
-                        .is_ok()
-                    {
-                        // We need to update the old ast state with the new settings!!
-                        cache::write_old_ast(OldAstState {
-                            ast: old_ast,
-                            exec_state: old_state.clone(),
-                            settings: self.settings.clone(),
-                            result_env,
-                        })
-                        .await;
-
-                        let outcome = old_state.to_exec_outcome(result_env).await;
-                        return Ok(outcome);
-                    }
-                    (true, program, old_ast.body.len(), None)
-                }
-                CacheResult::NoAction(false) => {
-                    let outcome = old_state.to_exec_outcome(result_env).await;
-                    return Ok(outcome);
-                }
-            };
-
-            let (exec_state, preserve_mem, universe_info) =
-                if let Some((new_universe, new_universe_map, mut new_exec_state)) = import_check_info {
-                    // Clear the scene if the imports changed.
-                    self.send_clear_scene(&mut new_exec_state, Default::default())
-                        .await
-                        .map_err(KclErrorWithOutputs::no_outputs)?;
-
-                    (new_exec_state, false, Some((new_universe, new_universe_map)))
-                } else if clear_scene {
-                    // Pop the execution state, since we are starting fresh.
-                    let mut exec_state = old_state;
-                    exec_state.reset(self);
-
-                    self.send_clear_scene(&mut exec_state, Default::default())
-                        .await
-                        .map_err(KclErrorWithOutputs::no_outputs)?;
-
-                    (exec_state, false, None)
-                } else {
-                    old_state.mut_stack().restore_env(result_env);
-
-                    (old_state, true, None)
+        let (program, exec_state, result) = match cache::read_old_ast().await {
+            Some(mut cached_state) => {
+                let old = CacheInformation {
+                    ast: &cached_state.main.ast,
+                    settings: &cached_state.settings,
+                };
+                let new = CacheInformation {
+                    ast: &program.ast,
+                    settings: &self.settings,
                 };
 
-            (program, exec_state, preserve_mem, body_items, universe_info)
-        } else {
-            let mut exec_state = ExecState::new(self);
-            self.send_clear_scene(&mut exec_state, Default::default())
-                .await
-                .map_err(KclErrorWithOutputs::no_outputs)?;
-            (program, exec_state, false, 0, None)
-        };
+                // Get the program that actually changed from the old and new information.
+                let (clear_scene, program, import_check_info) = match cache::get_changed_program(old, new).await {
+                    CacheResult::ReExecute {
+                        clear_scene,
+                        reapply_settings,
+                        program: changed_program,
+                    } => {
+                        if reapply_settings
+                            && self
+                                .engine
+                                .reapply_settings(
+                                    &self.settings,
+                                    Default::default(),
+                                    &mut cached_state.main.exec_state.id_generator,
+                                )
+                                .await
+                                .is_err()
+                        {
+                            (true, program, None)
+                        } else {
+                            (
+                                clear_scene,
+                                crate::Program {
+                                    ast: changed_program,
+                                    original_file_contents: program.original_file_contents,
+                                },
+                                None,
+                            )
+                        }
+                    }
+                    CacheResult::CheckImportsOnly {
+                        reapply_settings,
+                        ast: changed_program,
+                    } => {
+                        if reapply_settings
+                            && self
+                                .engine
+                                .reapply_settings(
+                                    &self.settings,
+                                    Default::default(),
+                                    &mut cached_state.main.exec_state.id_generator,
+                                )
+                                .await
+                                .is_err()
+                        {
+                            (true, program, None)
+                        } else {
+                            // We need to check our imports to see if they changed.
+                            let mut new_exec_state = ExecState::new(self);
+                            let (new_universe, new_universe_map) =
+                                self.get_universe(&program, &mut new_exec_state).await?;
 
-        let result = self
-            .run_concurrent(&program, cached_body_items, &mut exec_state, imports_info, preserve_mem)
-            .await;
+                            let clear_scene = new_universe.keys().any(|key| {
+                                let id = new_universe[key].1;
+                                match (
+                                    cached_state.exec_state.get_source(id),
+                                    new_exec_state.global.get_source(id),
+                                ) {
+                                    (Some(s0), Some(s1)) => s0.source != s1.source,
+                                    _ => false,
+                                }
+                            });
+
+                            if !clear_scene {
+                                // Return early we don't need to clear the scene.
+                                return Ok(cached_state.into_exec_outcome(self).await);
+                            }
+
+                            (
+                                true,
+                                crate::Program {
+                                    ast: changed_program,
+                                    original_file_contents: program.original_file_contents,
+                                },
+                                Some((new_universe, new_universe_map, new_exec_state)),
+                            )
+                        }
+                    }
+                    CacheResult::NoAction(true) => {
+                        if self
+                            .engine
+                            .reapply_settings(
+                                &self.settings,
+                                Default::default(),
+                                &mut cached_state.main.exec_state.id_generator,
+                            )
+                            .await
+                            .is_ok()
+                        {
+                            // We need to update the old ast state with the new settings!!
+                            cache::write_old_ast(GlobalState::with_settings(
+                                cached_state.clone(),
+                                self.settings.clone(),
+                            ))
+                            .await;
+
+                            return Ok(cached_state.into_exec_outcome(self).await);
+                        }
+                        (true, program, None)
+                    }
+                    CacheResult::NoAction(false) => {
+                        return Ok(cached_state.into_exec_outcome(self).await);
+                    }
+                };
+
+                let (exec_state, result) = match import_check_info {
+                    Some((new_universe, new_universe_map, mut new_exec_state)) => {
+                        // Clear the scene if the imports changed.
+                        self.send_clear_scene(&mut new_exec_state, Default::default())
+                            .await
+                            .map_err(KclErrorWithOutputs::no_outputs)?;
+
+                        let result = self
+                            .run_concurrent(
+                                &program,
+                                &mut new_exec_state,
+                                Some((new_universe, new_universe_map)),
+                                false,
+                            )
+                            .await;
+
+                        (new_exec_state, result)
+                    }
+                    None if clear_scene => {
+                        // Pop the execution state, since we are starting fresh.
+                        let mut exec_state = cached_state.reconstitute_exec_state();
+                        exec_state.reset(self);
+
+                        self.send_clear_scene(&mut exec_state, Default::default())
+                            .await
+                            .map_err(KclErrorWithOutputs::no_outputs)?;
+
+                        let result = self.run_concurrent(&program, &mut exec_state, None, false).await;
+
+                        (exec_state, result)
+                    }
+                    None => {
+                        let mut exec_state = cached_state.reconstitute_exec_state();
+                        exec_state.mut_stack().restore_env(cached_state.main.result_env);
+
+                        let result = self.run_concurrent(&program, &mut exec_state, None, true).await;
+
+                        (exec_state, result)
+                    }
+                };
+
+                (program, exec_state, result)
+            }
+            None => {
+                let mut exec_state = ExecState::new(self);
+                self.send_clear_scene(&mut exec_state, Default::default())
+                    .await
+                    .map_err(KclErrorWithOutputs::no_outputs)?;
+
+                let result = self.run_concurrent(&program, &mut exec_state, None, false).await;
+
+                (program, exec_state, result)
+            }
+        };
 
         if result.is_err() {
             cache::bust_cache().await;
@@ -766,15 +765,15 @@ impl ExecutorContext {
         let result = result?;
 
         // Save this as the last successful execution to the cache.
-        cache::write_old_ast(OldAstState {
-            ast: program.ast,
-            exec_state: exec_state.clone(),
-            settings: self.settings.clone(),
-            result_env: result.0,
-        })
+        cache::write_old_ast(GlobalState::new(
+            exec_state.clone(),
+            self.settings.clone(),
+            program.ast,
+            result.0,
+        ))
         .await;
 
-        let outcome = exec_state.to_exec_outcome(result.0).await;
+        let outcome = exec_state.to_exec_outcome(result.0, self).await;
         Ok(outcome)
     }
 
@@ -789,11 +788,11 @@ impl ExecutorContext {
         program: &crate::Program,
         exec_state: &mut ExecState,
     ) -> Result<(EnvironmentRef, Option<ModelingSessionData>), KclErrorWithOutputs> {
-        self.run_concurrent(program, 0, exec_state, None, false).await
+        self.run_concurrent(program, exec_state, None, false).await
     }
 
     /// Perform the execution of a program using a concurrent
-    /// execution model. This has the same signature as [Self::run].
+    /// execution model.
     ///
     /// You can optionally pass in some initialization memory for partial
     /// execution.
@@ -802,13 +801,12 @@ impl ExecutorContext {
     pub async fn run_concurrent(
         &self,
         program: &crate::Program,
-        cached_body_items: usize,
         exec_state: &mut ExecState,
         universe_info: Option<(Universe, UniverseMap)>,
         preserve_mem: bool,
     ) -> Result<(EnvironmentRef, Option<ModelingSessionData>), KclErrorWithOutputs> {
         // Reuse our cached universe if we have one.
-        #[allow(unused_variables)]
+
         let (universe, universe_map) = if let Some((universe, universe_map)) = universe_info {
             (universe, universe_map)
         } else {
@@ -822,29 +820,8 @@ impl ExecutorContext {
             .await
             .map_err(KclErrorWithOutputs::no_outputs)?;
 
-        for modules in crate::walk::import_graph(&universe, self)
-            .map_err(|err| {
-                let module_id_to_module_path: IndexMap<ModuleId, ModulePath> = exec_state
-                    .global
-                    .path_to_source_id
-                    .iter()
-                    .map(|(k, v)| ((*v), k.clone()))
-                    .collect();
-
-                KclErrorWithOutputs::new(
-                    err,
-                    exec_state.errors().to_vec(),
-                    #[cfg(feature = "artifact-graph")]
-                    exec_state.global.operations.clone(),
-                    #[cfg(feature = "artifact-graph")]
-                    exec_state.global.artifact_commands.clone(),
-                    #[cfg(feature = "artifact-graph")]
-                    exec_state.global.artifact_graph.clone(),
-                    module_id_to_module_path,
-                    exec_state.global.id_to_source.clone(),
-                    default_planes.clone(),
-                )
-            })?
+        for modules in import_graph::import_graph(&universe, self)
+            .map_err(|err| exec_state.error_with_outputs(err, default_planes.clone()))?
             .into_iter()
         {
             #[cfg(not(target_arch = "wasm32"))]
@@ -866,32 +843,14 @@ impl ExecutorContext {
                 let module_path = module_path.clone();
                 let source_range = SourceRange::from(import_stmt);
 
-                #[cfg(feature = "artifact-graph")]
-                match &module_path {
-                    ModulePath::Main => {
-                        // This should never happen.
-                    }
-                    ModulePath::Local { value, .. } => {
-                        // We only want to display the top-level module imports in
-                        // the Feature Tree, not transitive imports.
-                        if universe_map.contains_key(value) {
-                            exec_state.global.operations.push(Operation::GroupBegin {
-                                group: Group::ModuleInstance {
-                                    name: value.file_name().unwrap_or_default(),
-                                    module_id,
-                                },
-                                source_range,
-                            });
-                            // Due to concurrent execution, we cannot easily
-                            // group operations by module. So we leave the
-                            // group empty and close it immediately.
-                            exec_state.global.operations.push(Operation::GroupEnd);
-                        }
-                    }
-                    ModulePath::Std { .. } => {
-                        // We don't want to display stdlib in the Feature Tree.
-                    }
-                }
+                self.add_import_module_ops(
+                    exec_state,
+                    program,
+                    module_id,
+                    &module_path,
+                    source_range,
+                    &universe_map,
+                );
 
                 let repr = repr.clone();
                 let exec_state = exec_state.clone();
@@ -930,7 +889,6 @@ impl ExecutorContext {
                 #[cfg(target_arch = "wasm32")]
                 {
                     wasm_bindgen_futures::spawn_local(async move {
-                        //set.spawn(async move {
                         let mut exec_state = exec_state;
                         let exec_ctxt = exec_ctxt;
 
@@ -1000,33 +958,13 @@ impl ExecutorContext {
                         exec_state.global.module_infos[&module_id].restore_repr(repr);
                     }
                     Err(e) => {
-                        let module_id_to_module_path: IndexMap<ModuleId, ModulePath> = exec_state
-                            .global
-                            .path_to_source_id
-                            .iter()
-                            .map(|(k, v)| ((*v), k.clone()))
-                            .collect();
-
-                        return Err(KclErrorWithOutputs::new(
-                            e,
-                            exec_state.errors().to_vec(),
-                            #[cfg(feature = "artifact-graph")]
-                            exec_state.global.operations.clone(),
-                            #[cfg(feature = "artifact-graph")]
-                            exec_state.global.artifact_commands.clone(),
-                            #[cfg(feature = "artifact-graph")]
-                            exec_state.global.artifact_graph.clone(),
-                            module_id_to_module_path,
-                            exec_state.global.id_to_source.clone(),
-                            default_planes,
-                        ));
+                        return Err(exec_state.error_with_outputs(e, default_planes));
                     }
                 }
             }
         }
 
-        self.inner_run(program, cached_body_items, exec_state, preserve_mem)
-            .await
+        self.inner_run(program, exec_state, preserve_mem).await
     }
 
     /// Get the universe & universe map of the program.
@@ -1042,7 +980,7 @@ impl ExecutorContext {
 
         let default_planes = self.engine.get_default_planes().read().await.clone();
 
-        let root_imports = crate::walk::import_universe(
+        let root_imports = import_graph::import_universe(
             self,
             &ModulePath::Main,
             &ModuleRepr::Kcl(program.ast.clone(), None),
@@ -1050,39 +988,77 @@ impl ExecutorContext {
             exec_state,
         )
         .await
-        .map_err(|err| {
-            println!("Error: {err:?}");
-            let module_id_to_module_path: IndexMap<ModuleId, ModulePath> = exec_state
-                .global
-                .path_to_source_id
-                .iter()
-                .map(|(k, v)| ((*v), k.clone()))
-                .collect();
-
-            KclErrorWithOutputs::new(
-                err,
-                exec_state.errors().to_vec(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.operations.clone(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.artifact_commands.clone(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.artifact_graph.clone(),
-                module_id_to_module_path,
-                exec_state.global.id_to_source.clone(),
-                default_planes,
-            )
-        })?;
+        .map_err(|err| exec_state.error_with_outputs(err, default_planes))?;
 
         Ok((universe, root_imports))
     }
 
+    #[cfg(feature = "artifact-graph")]
+    fn add_import_module_ops(
+        &self,
+        exec_state: &mut ExecState,
+        program: &crate::Program,
+        module_id: ModuleId,
+        module_path: &ModulePath,
+        source_range: SourceRange,
+        universe_map: &UniverseMap,
+    ) {
+        match module_path {
+            ModulePath::Main => {
+                // This should never happen.
+            }
+            ModulePath::Local { value, .. } => {
+                // We only want to display the top-level module imports in
+                // the Feature Tree, not transitive imports.
+                if universe_map.contains_key(value) {
+                    use crate::NodePath;
+
+                    let node_path = if source_range.is_top_level_module() {
+                        let cached_body_items = exec_state.global.artifacts.cached_body_items();
+                        NodePath::from_range(&program.ast, cached_body_items, source_range).unwrap_or_default()
+                    } else {
+                        // The frontend doesn't care about paths in
+                        // files other than the top-level module.
+                        NodePath::placeholder()
+                    };
+
+                    exec_state.push_op(Operation::GroupBegin {
+                        group: Group::ModuleInstance {
+                            name: value.file_name().unwrap_or_default(),
+                            module_id,
+                        },
+                        node_path,
+                        source_range,
+                    });
+                    // Due to concurrent execution, we cannot easily
+                    // group operations by module. So we leave the
+                    // group empty and close it immediately.
+                    exec_state.push_op(Operation::GroupEnd);
+                }
+            }
+            ModulePath::Std { .. } => {
+                // We don't want to display stdlib in the Feature Tree.
+            }
+        }
+    }
+
+    #[cfg(not(feature = "artifact-graph"))]
+    fn add_import_module_ops(
+        &self,
+        _exec_state: &mut ExecState,
+        _program: &crate::Program,
+        _module_id: ModuleId,
+        _module_path: &ModulePath,
+        _source_range: SourceRange,
+        _universe_map: &UniverseMap,
+    ) {
+    }
+
     /// Perform the execution of a program.  Accept all possible parameters and
     /// output everything.
     async fn inner_run(
         &self,
         program: &crate::Program,
-        cached_body_items: usize,
         exec_state: &mut ExecState,
         preserve_mem: bool,
     ) -> Result<(EnvironmentRef, Option<ModelingSessionData>), KclErrorWithOutputs> {
@@ -1096,7 +1072,7 @@ impl ExecutorContext {
 
         let default_planes = self.engine.get_default_planes().read().await.clone();
         let result = self
-            .execute_and_build_graph(&program.ast, cached_body_items, exec_state, preserve_mem)
+            .execute_and_build_graph(&program.ast, exec_state, preserve_mem)
             .await;
 
         crate::log::log(format!(
@@ -1105,28 +1081,7 @@ impl ExecutorContext {
         ));
         crate::log::log(format!("Engine stats: {:?}", self.engine.stats()));
 
-        let env_ref = result.map_err(|e| {
-            let module_id_to_module_path: IndexMap<ModuleId, ModulePath> = exec_state
-                .global
-                .path_to_source_id
-                .iter()
-                .map(|(k, v)| ((*v), k.clone()))
-                .collect();
-
-            KclErrorWithOutputs::new(
-                e,
-                exec_state.errors().to_vec(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.operations.clone(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.artifact_commands.clone(),
-                #[cfg(feature = "artifact-graph")]
-                exec_state.global.artifact_graph.clone(),
-                module_id_to_module_path,
-                exec_state.global.id_to_source.clone(),
-                default_planes.clone(),
-            )
-        })?;
+        let env_ref = result.map_err(|e| exec_state.error_with_outputs(e, default_planes))?;
 
         if !self.is_mock() {
             let mut mem = exec_state.stack().deep_clone();
@@ -1143,13 +1098,17 @@ impl ExecutorContext {
     async fn execute_and_build_graph(
         &self,
         program: NodeRef<'_, crate::parsing::ast::types::Program>,
-        #[cfg_attr(not(feature = "artifact-graph"), expect(unused))] cached_body_items: usize,
         exec_state: &mut ExecState,
         preserve_mem: bool,
     ) -> Result<EnvironmentRef, KclError> {
         // Don't early return!  We need to build other outputs regardless of
         // whether execution failed.
 
+        // Because of execution caching, we may start with operations from a
+        // previous run.
+        #[cfg(feature = "artifact-graph")]
+        let start_op = exec_state.global.artifacts.operations.len();
+
         self.eval_prelude(exec_state, SourceRange::from(program).start_as_range())
             .await?;
 
@@ -1163,6 +1122,29 @@ impl ExecutorContext {
             )
             .await;
 
+        #[cfg(feature = "artifact-graph")]
+        {
+            // Fill in NodePath for operations.
+            let cached_body_items = exec_state.global.artifacts.cached_body_items();
+            for op in exec_state.global.artifacts.operations.iter_mut().skip(start_op) {
+                match op {
+                    Operation::StdLibCall {
+                        node_path,
+                        source_range,
+                        ..
+                    }
+                    | Operation::GroupBegin {
+                        node_path,
+                        source_range,
+                        ..
+                    } => {
+                        node_path.fill_placeholder(program, cached_body_items, *source_range);
+                    }
+                    Operation::GroupEnd => {}
+                }
+            }
+        }
+
         // Ensure all the async commands completed.
         self.engine.ensure_async_commands_completed().await?;
 
@@ -1170,40 +1152,9 @@ impl ExecutorContext {
         // and should be dropped.
         self.engine.clear_queues().await;
 
-        #[cfg(feature = "artifact-graph")]
-        {
-            let new_commands = self.engine.take_artifact_commands().await;
-            let new_responses = self.engine.take_responses().await;
-            let initial_graph = exec_state.global.artifact_graph.clone();
-
-            // Build the artifact graph.
-            let graph_result = build_artifact_graph(
-                &new_commands,
-                &new_responses,
-                program,
-                cached_body_items,
-                &mut exec_state.global.artifacts,
-                initial_graph,
-            );
-            // Move the artifact commands and responses into ExecState to
-            // simplify cache management and error creation.
-            exec_state.global.artifact_commands.extend(new_commands);
-            exec_state.global.artifact_responses.extend(new_responses);
-
-            match graph_result {
-                Ok(artifact_graph) => {
-                    exec_state.global.artifact_graph = artifact_graph;
-                    exec_result.map(|(_, env_ref, _)| env_ref)
-                }
-                Err(err) => {
-                    // Prefer the exec error.
-                    exec_result.and(Err(err))
-                }
-            }
-        }
-        #[cfg(not(feature = "artifact-graph"))]
-        {
-            exec_result.map(|(_, env_ref, _)| env_ref)
+        match exec_state.build_artifact_graph(&self.engine, program).await {
+            Ok(_) => exec_result.map(|(_, env_ref, _)| env_ref),
+            Err(err) => exec_result.and(Err(err)),
         }
     }
 
@@ -1390,7 +1341,6 @@ pub(crate) async fn parse_execute_with_project_dir(
             })?,
         )),
         fs: Arc::new(crate::fs::FileManager::new()),
-        stdlib: Arc::new(crate::std::StdLib::new()),
         settings: ExecutorSettings {
             project_directory,
             ..Default::default()
@@ -2072,7 +2022,7 @@ notPipeSub = 1 |> identity(!%))";
             // a runtime error instead.
             parse_execute(code11).await.unwrap_err(),
             KclError::new_syntax(KclErrorDetails::new(
-                "There was an unexpected !. Try removing it.".to_owned(),
+                "There was an unexpected `!`. Try removing it.".to_owned(),
                 vec![SourceRange::new(56, 57, ModuleId::default())],
             ))
         );
@@ -2206,7 +2156,7 @@ w = f() + f()
         }
 
         // Get the id_generator from the first execution.
-        let id_generator = cache::read_old_ast().await.unwrap().exec_state.mod_local.id_generator;
+        let id_generator = cache::read_old_ast().await.unwrap().main.exec_state.id_generator;
 
         let code = r#"sketch001 = startSketchOn(XZ)
 |> startProfile(at = [62.74, 206.13])
@@ -2227,7 +2177,7 @@ w = f() + f()
         // Execute the program.
         ctx.run_with_caching(program).await.unwrap();
 
-        let new_id_generator = cache::read_old_ast().await.unwrap().exec_state.mod_local.id_generator;
+        let new_id_generator = cache::read_old_ast().await.unwrap().main.exec_state.id_generator;
 
         assert_eq!(id_generator, new_id_generator);
     }

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

@@ -12,19 +12,19 @@ use uuid::Uuid;
 use crate::execution::{Artifact, ArtifactCommand, ArtifactGraph, ArtifactId};
 use crate::{
     errors::{KclError, KclErrorDetails, Severity},
+    exec::DefaultPlanes,
     execution::{
         annotations,
         cad_op::Operation,
         id_generator::IdGenerator,
         memory::{ProgramMemory, Stack},
-        types,
-        types::NumericType,
+        types::{self, NumericType},
         EnvironmentRef, ExecOutcome, ExecutorSettings, KclValue, UnitAngle, UnitLen,
     },
     modules::{ModuleId, ModuleInfo, ModuleLoader, ModulePath, ModuleRepr, ModuleSource},
-    parsing::ast::types::Annotation,
+    parsing::ast::types::{Annotation, NodeRef},
     source_range::SourceRange,
-    CompilationError,
+    CompilationError, EngineManager, ExecutorContext, KclErrorWithOutputs,
 };
 
 /// State for executing a program.
@@ -32,7 +32,6 @@ use crate::{
 pub struct ExecState {
     pub(super) global: GlobalState,
     pub(super) mod_local: ModuleState,
-    pub(super) exec_context: Option<super::ExecutorContext>,
 }
 
 pub type ModuleInfoMap = IndexMap<ModuleId, ModuleInfo>;
@@ -45,33 +44,39 @@ pub(super) struct GlobalState {
     pub id_to_source: IndexMap<ModuleId, ModuleSource>,
     /// Map from module ID to module info.
     pub module_infos: ModuleInfoMap,
-    /// Output map of UUIDs to artifacts.
-    #[cfg(feature = "artifact-graph")]
-    pub artifacts: IndexMap<ArtifactId, Artifact>,
-    /// Output commands to allow building the artifact graph by the caller.
-    /// These are accumulated in the [`ExecutorContext`] but moved here for
-    /// convenience of the execution cache.
-    #[cfg(feature = "artifact-graph")]
-    pub artifact_commands: Vec<ArtifactCommand>,
-    /// Responses from the engine for `artifact_commands`.  We need to cache
-    /// this so that we can build the artifact graph.  These are accumulated in
-    /// the [`ExecutorContext`] but moved here for convenience of the execution
-    /// cache.
-    #[cfg(feature = "artifact-graph")]
-    pub artifact_responses: IndexMap<Uuid, WebSocketResponse>,
-    /// Output artifact graph.
-    #[cfg(feature = "artifact-graph")]
-    pub artifact_graph: ArtifactGraph,
-    /// Operations that have been performed in execution order, for display in
-    /// the Feature Tree.
-    #[cfg(feature = "artifact-graph")]
-    pub operations: Vec<Operation>,
     /// Module loader.
     pub mod_loader: ModuleLoader,
     /// Errors and warnings.
     pub errors: Vec<CompilationError>,
+    #[allow(dead_code)]
+    pub artifacts: ArtifactState,
 }
 
+#[cfg(feature = "artifact-graph")]
+#[derive(Debug, Clone, Default)]
+pub(super) struct ArtifactState {
+    /// Output map of UUIDs to artifacts.
+    pub artifacts: IndexMap<ArtifactId, Artifact>,
+    /// Output commands to allow building the artifact graph by the caller.
+    /// These are accumulated in the [`ExecutorContext`] but moved here for
+    /// convenience of the execution cache.
+    pub commands: Vec<ArtifactCommand>,
+    /// Responses from the engine for `artifact_commands`.  We need to cache
+    /// this so that we can build the artifact graph.  These are accumulated in
+    /// the [`ExecutorContext`] but moved here for convenience of the execution
+    /// cache.
+    pub responses: IndexMap<Uuid, WebSocketResponse>,
+    /// Output artifact graph.
+    pub graph: ArtifactGraph,
+    /// Operations that have been performed in execution order, for display in
+    /// the Feature Tree.
+    pub operations: Vec<Operation>,
+}
+
+#[cfg(not(feature = "artifact-graph"))]
+#[derive(Debug, Clone, Default)]
+pub(super) struct ArtifactState {}
+
 #[derive(Debug, Clone)]
 pub(super) struct ModuleState {
     /// The id generator for this module.
@@ -98,7 +103,6 @@ impl ExecState {
         ExecState {
             global: GlobalState::new(&exec_context.settings),
             mod_local: ModuleState::new(ModulePath::Main, ProgramMemory::new(), Default::default()),
-            exec_context: Some(exec_context.clone()),
         }
     }
 
@@ -108,7 +112,6 @@ impl ExecState {
         *self = ExecState {
             global,
             mod_local: ModuleState::new(self.mod_local.path.clone(), ProgramMemory::new(), Default::default()),
-            exec_context: Some(exec_context.clone()),
         };
     }
 
@@ -130,45 +133,26 @@ impl ExecState {
     /// Convert to execution outcome when running in WebAssembly.  We want to
     /// reduce the amount of data that crosses the WASM boundary as much as
     /// possible.
-    pub async fn to_exec_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
+    pub async fn to_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
         // Fields are opt-in so that we don't accidentally leak private internal
         // state when we add more to ExecState.
         ExecOutcome {
-            variables: self
-                .stack()
-                .find_all_in_env(main_ref)
-                .map(|(k, v)| (k.clone(), v.clone()))
-                .collect(),
+            variables: self.mod_local.variables(main_ref),
+            filenames: self.global.filenames(),
             #[cfg(feature = "artifact-graph")]
-            operations: self.global.operations,
+            operations: self.global.artifacts.operations,
             #[cfg(feature = "artifact-graph")]
-            artifact_commands: self.global.artifact_commands,
+            artifact_commands: self.global.artifacts.commands,
             #[cfg(feature = "artifact-graph")]
-            artifact_graph: self.global.artifact_graph,
+            artifact_graph: self.global.artifacts.graph,
             errors: self.global.errors,
-            filenames: self
-                .global
-                .path_to_source_id
-                .iter()
-                .map(|(k, v)| ((*v), k.clone()))
-                .collect(),
-            default_planes: if let Some(ctx) = &self.exec_context {
-                ctx.engine.get_default_planes().read().await.clone()
-            } else {
-                None
-            },
+            default_planes: ctx.engine.get_default_planes().read().await.clone(),
         }
     }
 
-    pub async fn to_mock_exec_outcome(self, main_ref: EnvironmentRef) -> ExecOutcome {
-        // Fields are opt-in so that we don't accidentally leak private internal
-        // state when we add more to ExecState.
+    pub async fn to_mock_exec_outcome(self, main_ref: EnvironmentRef, ctx: &ExecutorContext) -> ExecOutcome {
         ExecOutcome {
-            variables: self
-                .stack()
-                .find_all_in_env(main_ref)
-                .map(|(k, v)| (k.clone(), v.clone()))
-                .collect(),
+            variables: self.mod_local.variables(main_ref),
             #[cfg(feature = "artifact-graph")]
             operations: Default::default(),
             #[cfg(feature = "artifact-graph")]
@@ -177,11 +161,7 @@ impl ExecState {
             artifact_graph: Default::default(),
             errors: self.global.errors,
             filenames: Default::default(),
-            default_planes: if let Some(ctx) = &self.exec_context {
-                ctx.engine.get_default_planes().read().await.clone()
-            } else {
-                None
-            },
+            default_planes: ctx.engine.get_default_planes().read().await.clone(),
         }
     }
 
@@ -204,12 +184,12 @@ impl ExecState {
     #[cfg(feature = "artifact-graph")]
     pub(crate) fn add_artifact(&mut self, artifact: Artifact) {
         let id = artifact.id();
-        self.global.artifacts.insert(id, artifact);
+        self.global.artifacts.artifacts.insert(id, artifact);
     }
 
     pub(crate) fn push_op(&mut self, op: Operation) {
         #[cfg(feature = "artifact-graph")]
-        self.global.operations.push(op);
+        self.global.artifacts.operations.push(op);
         #[cfg(not(feature = "artifact-graph"))]
         drop(op);
     }
@@ -251,10 +231,6 @@ impl ExecState {
         self.global.id_to_source.insert(id, source.clone());
     }
 
-    pub(super) fn get_source(&self, id: ModuleId) -> Option<&ModuleSource> {
-        self.global.id_to_source.get(&id)
-    }
-
     pub(super) fn add_module(&mut self, id: ModuleId, path: ModulePath, repr: ModuleRepr) {
         debug_assert!(self.global.path_to_source_id.contains_key(&path));
         let module_info = ModuleInfo { id, repr, path };
@@ -300,6 +276,71 @@ impl ExecState {
     pub(crate) fn pipe_value(&self) -> Option<&KclValue> {
         self.mod_local.pipe_value.as_ref()
     }
+
+    pub(crate) fn error_with_outputs(
+        &self,
+        error: KclError,
+        default_planes: Option<DefaultPlanes>,
+    ) -> KclErrorWithOutputs {
+        let module_id_to_module_path: IndexMap<ModuleId, ModulePath> = self
+            .global
+            .path_to_source_id
+            .iter()
+            .map(|(k, v)| ((*v), k.clone()))
+            .collect();
+
+        KclErrorWithOutputs::new(
+            error,
+            self.errors().to_vec(),
+            #[cfg(feature = "artifact-graph")]
+            self.global.artifacts.operations.clone(),
+            #[cfg(feature = "artifact-graph")]
+            self.global.artifacts.commands.clone(),
+            #[cfg(feature = "artifact-graph")]
+            self.global.artifacts.graph.clone(),
+            module_id_to_module_path,
+            self.global.id_to_source.clone(),
+            default_planes,
+        )
+    }
+
+    #[cfg(feature = "artifact-graph")]
+    pub(crate) async fn build_artifact_graph(
+        &mut self,
+        engine: &Arc<Box<dyn EngineManager>>,
+        program: NodeRef<'_, crate::parsing::ast::types::Program>,
+    ) -> Result<(), KclError> {
+        let new_commands = engine.take_artifact_commands().await;
+        let new_responses = engine.take_responses().await;
+        let initial_graph = self.global.artifacts.graph.clone();
+
+        // Build the artifact graph.
+        let graph_result = crate::execution::artifact::build_artifact_graph(
+            &new_commands,
+            &new_responses,
+            program,
+            &mut self.global.artifacts.artifacts,
+            initial_graph,
+        );
+        // Move the artifact commands and responses into ExecState to
+        // simplify cache management and error creation.
+        self.global.artifacts.commands.extend(new_commands);
+        self.global.artifacts.responses.extend(new_responses);
+
+        let artifact_graph = graph_result?;
+        self.global.artifacts.graph = artifact_graph;
+
+        Ok(())
+    }
+
+    #[cfg(not(feature = "artifact-graph"))]
+    pub(crate) async fn build_artifact_graph(
+        &mut self,
+        _engine: &Arc<Box<dyn EngineManager>>,
+        _program: NodeRef<'_, crate::parsing::ast::types::Program>,
+    ) -> Result<(), KclError> {
+        Ok(())
+    }
 }
 
 impl GlobalState {
@@ -307,16 +348,7 @@ impl GlobalState {
         let mut global = GlobalState {
             path_to_source_id: Default::default(),
             module_infos: Default::default(),
-            #[cfg(feature = "artifact-graph")]
             artifacts: Default::default(),
-            #[cfg(feature = "artifact-graph")]
-            artifact_commands: Default::default(),
-            #[cfg(feature = "artifact-graph")]
-            artifact_responses: Default::default(),
-            #[cfg(feature = "artifact-graph")]
-            artifact_graph: Default::default(),
-            #[cfg(feature = "artifact-graph")]
-            operations: Default::default(),
             mod_loader: Default::default(),
             errors: Default::default(),
             id_to_source: Default::default(),
@@ -339,6 +371,21 @@ impl GlobalState {
             .insert(ModulePath::Local { value: root_path }, root_id);
         global
     }
+
+    pub(super) fn filenames(&self) -> IndexMap<ModuleId, ModulePath> {
+        self.path_to_source_id.iter().map(|(k, v)| ((*v), k.clone())).collect()
+    }
+
+    pub(super) fn get_source(&self, id: ModuleId) -> Option<&ModuleSource> {
+        self.id_to_source.get(&id)
+    }
+}
+
+#[cfg(feature = "artifact-graph")]
+impl ArtifactState {
+    pub fn cached_body_items(&self) -> usize {
+        self.graph.item_count
+    }
 }
 
 impl ModuleState {
@@ -358,6 +405,13 @@ impl ModuleState {
             },
         }
     }
+
+    pub(super) fn variables(&self, main_ref: EnvironmentRef) -> IndexMap<String, KclValue> {
+        self.stack
+            .find_all_in_env(main_ref)
+            .map(|(k, v)| (k.clone(), v.clone()))
+            .collect()
+    }
 }
 
 #[derive(Debug, Default, Clone, Deserialize, Serialize, PartialEq, Eq, ts_rs::TS, JsonSchema)]

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

@@ -220,6 +220,7 @@ impl schemars::JsonSchema for TypedPath {
 ///
 /// * Does **not** touch `..` or symlinks – call `canonicalize()` if you need that.
 /// * Returns an owned `PathBuf` only when normalisation was required.
+#[cfg(not(target_arch = "wasm32"))]
 fn normalise_import<S: AsRef<str>>(raw: S) -> std::path::PathBuf {
     let s = raw.as_ref();
     // On Unix we need to swap `\` → `/`.  On Windows we leave it alone.

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

@@ -187,7 +187,7 @@ impl RuntimeType {
                 };
                 RuntimeType::Primitive(PrimitiveType::Number(ty))
             }
-            AstPrimitiveType::Named(name) => Self::from_alias(&name.name, exec_state, source_range)?,
+            AstPrimitiveType::Named { id } => Self::from_alias(&id.name, exec_state, source_range)?,
             AstPrimitiveType::Tag => RuntimeType::Primitive(PrimitiveType::Tag),
             AstPrimitiveType::ImportedGeometry => RuntimeType::Primitive(PrimitiveType::ImportedGeometry),
             AstPrimitiveType::Function(_) => RuntimeType::Primitive(PrimitiveType::Function),

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

@@ -247,17 +247,6 @@ impl ObjectProperty {
     }
 }
 
-impl MemberObject {
-    fn get_hover_value_for_position(&self, pos: usize, code: &str, opts: &HoverOpts) -> Option<Hover> {
-        match self {
-            MemberObject::MemberExpression(member_expression) => {
-                member_expression.get_hover_value_for_position(pos, code, opts)
-            }
-            MemberObject::Identifier(_identifier) => None,
-        }
-    }
-}
-
 impl MemberExpression {
     fn get_hover_value_for_position(&self, pos: usize, code: &str, opts: &HoverOpts) -> Option<Hover> {
         let object_source_range: SourceRange = self.object.clone().into();

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

@@ -175,11 +175,10 @@ impl Backend {
         zoo_client: kittycad::Client,
         can_send_telemetry: bool,
     ) -> Result<Self, String> {
-        let stdlib = crate::std::StdLib::new();
         let kcl_std = crate::docs::kcl_doc::walk_prelude();
-        let stdlib_completions = get_completions_from_stdlib(&stdlib, &kcl_std).map_err(|e| e.to_string())?;
-        let stdlib_signatures = get_signatures_from_stdlib(&stdlib, &kcl_std);
-        let stdlib_args = get_arg_maps_from_stdlib(&stdlib, &kcl_std);
+        let stdlib_completions = get_completions_from_stdlib(&kcl_std).map_err(|e| e.to_string())?;
+        let stdlib_signatures = get_signatures_from_stdlib(&kcl_std);
+        let stdlib_args = get_arg_maps_from_stdlib(&kcl_std);
 
         Ok(Self {
             client,
@@ -1189,7 +1188,6 @@ impl LanguageServer for Backend {
     }
 
     async fn completion(&self, params: CompletionParams) -> RpcResult<Option<CompletionResponse>> {
-        // ADAM: This is the entrypoint.
         let mut completions = vec![CompletionItem {
             label: PIPE_OPERATOR.to_string(),
             label_details: None,
@@ -1635,16 +1633,8 @@ impl LanguageServer for Backend {
 }
 
 /// Get completions from our stdlib.
-pub fn get_completions_from_stdlib(
-    stdlib: &crate::std::StdLib,
-    kcl_std: &ModData,
-) -> Result<HashMap<String, CompletionItem>> {
+pub fn get_completions_from_stdlib(kcl_std: &ModData) -> Result<HashMap<String, CompletionItem>> {
     let mut completions = HashMap::new();
-    let combined = stdlib.combined();
-
-    for internal_fn in combined.values() {
-        completions.insert(internal_fn.name(), internal_fn.to_completion_item()?);
-    }
 
     for d in kcl_std.all_docs() {
         if let Some(ci) = d.to_completion_item() {
@@ -1661,13 +1651,8 @@ pub fn get_completions_from_stdlib(
 }
 
 /// Get signatures from our stdlib.
-pub fn get_signatures_from_stdlib(stdlib: &crate::std::StdLib, kcl_std: &ModData) -> HashMap<String, SignatureHelp> {
+pub fn get_signatures_from_stdlib(kcl_std: &ModData) -> HashMap<String, SignatureHelp> {
     let mut signatures = HashMap::new();
-    let combined = stdlib.combined();
-
-    for internal_fn in combined.values() {
-        signatures.insert(internal_fn.name(), internal_fn.to_signature_help());
-    }
 
     for d in kcl_std.all_docs() {
         if let Some(sig) = d.to_signature_help() {
@@ -1679,44 +1664,32 @@ pub fn get_signatures_from_stdlib(stdlib: &crate::std::StdLib, kcl_std: &ModData
 }
 
 /// Get signatures from our stdlib.
-pub fn get_arg_maps_from_stdlib(
-    stdlib: &crate::std::StdLib,
-    kcl_std: &ModData,
-) -> HashMap<String, HashMap<String, String>> {
+pub fn get_arg_maps_from_stdlib(kcl_std: &ModData) -> HashMap<String, HashMap<String, String>> {
     let mut result = HashMap::new();
-    let combined = stdlib.combined();
 
-    for internal_fn in combined.values() {
-        let arg_map: HashMap<String, String> = internal_fn
-            .args(false)
-            .into_iter()
+    for d in kcl_std.all_docs() {
+        let crate::docs::kcl_doc::DocData::Fn(f) = d else {
+            continue;
+        };
+        let arg_map: HashMap<String, String> = f
+            .args
+            .iter()
             .map(|data| {
                 let mut tip = "```\n".to_owned();
-                tip.push_str(&data.name.clone());
-                if !data.required {
-                    tip.push('?');
-                }
-                if !data.type_.is_empty() {
-                    tip.push_str(": ");
-                    tip.push_str(&data.type_);
-                }
+                tip.push_str(&data.to_string());
                 tip.push_str("\n```");
-                if !data.description.is_empty() {
+                if let Some(docs) = &data.docs {
                     tip.push_str("\n\n");
-                    tip.push_str(&data.description);
+                    tip.push_str(docs);
                 }
-                (data.name, tip)
+                (data.name.clone(), tip)
             })
             .collect();
         if !arg_map.is_empty() {
-            result.insert(internal_fn.name(), arg_map);
+            result.insert(f.name.clone(), arg_map);
         }
     }
 
-    for _d in kcl_std.all_docs() {
-        // TODO add KCL std fns
-    }
-
     result
 }
 

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

@@ -5,11 +5,10 @@ use tower_lsp::LanguageServer;
 
 // Create a fake kcl lsp server for testing.
 pub async fn kcl_lsp_server(execute: bool) -> Result<crate::lsp::kcl::Backend> {
-    let stdlib = crate::std::StdLib::new();
     let kcl_std = crate::docs::kcl_doc::walk_prelude();
-    let stdlib_completions = crate::lsp::kcl::get_completions_from_stdlib(&stdlib, &kcl_std)?;
-    let stdlib_signatures = crate::lsp::kcl::get_signatures_from_stdlib(&stdlib, &kcl_std);
-    let stdlib_args = crate::lsp::kcl::get_arg_maps_from_stdlib(&stdlib, &kcl_std);
+    let stdlib_completions = crate::lsp::kcl::get_completions_from_stdlib(&kcl_std)?;
+    let stdlib_signatures = crate::lsp::kcl::get_signatures_from_stdlib(&kcl_std);
+    let stdlib_args = crate::lsp::kcl::get_arg_maps_from_stdlib(&kcl_std);
 
     let zoo_client = crate::engine::new_zoo_client(None, None)?;
 

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

@@ -928,7 +928,7 @@ startSketchOn(XY)
     match hover.unwrap().contents {
         tower_lsp::lsp_types::HoverContents::Markup(tower_lsp::lsp_types::MarkupContent { value, .. }) => {
             assert!(value.contains("startSketchOn"));
-            assert!(value.contains(": SketchSurface"));
+            assert!(value.contains(": Plane | Face"));
             assert!(value.contains("Start a new 2-dimensional sketch on a specific"));
         }
         _ => unreachable!(),
@@ -1113,13 +1113,7 @@ async fn test_kcl_lsp_signature_help() {
             "Expected one signature, got {:?}",
             signature_help.signatures
         );
-        assert_eq!(
-            signature_help.signatures[0].label,
-            r#"startSketchOn(
-  @planeOrSolid: SketchData,
-  face?: FaceTag,
-): SketchSurface"#
-        );
+        assert!(signature_help.signatures[0].label.starts_with("startSketchOn"));
     } else {
         panic!("Expected signature help");
     }
@@ -3884,7 +3878,7 @@ startSketchOn(XY)
     match hover.unwrap().contents {
         tower_lsp::lsp_types::HoverContents::Markup(tower_lsp::lsp_types::MarkupContent { value, .. }) => {
             assert!(value.contains("startSketchOn"));
-            assert!(value.contains(": SketchSurface"));
+            assert!(value.contains(": Plane | Face"));
             assert!(value.contains("Start a new 2-dimensional sketch on a specific"));
         }
         _ => unreachable!(),

rust/kcl-lib/src/parsing/ast/digest.rs

@@ -4,7 +4,7 @@ use crate::parsing::ast::types::{
     Annotation, ArrayExpression, ArrayRangeExpression, AscribedExpression, BinaryExpression, BinaryPart, BodyItem,
     CallExpressionKw, DefaultParamVal, ElseIf, Expr, ExpressionStatement, FunctionExpression, FunctionType, Identifier,
     IfExpression, ImportItem, ImportSelector, ImportStatement, ItemVisibility, KclNone, LabelledExpression, Literal,
-    LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Name, ObjectExpression, ObjectProperty, Parameter,
+    LiteralIdentifier, LiteralValue, MemberExpression, Name, ObjectExpression, ObjectProperty, Parameter,
     PipeExpression, PipeSubstitution, PrimitiveType, Program, ReturnStatement, TagDeclarator, Type, TypeDeclaration,
     UnaryExpression, VariableDeclaration, VariableDeclarator, VariableKind,
 };
@@ -167,15 +167,6 @@ impl BinaryPart {
     }
 }
 
-impl MemberObject {
-    pub fn compute_digest(&mut self) -> Digest {
-        match self {
-            MemberObject::MemberExpression(me) => me.compute_digest(),
-            MemberObject::Identifier(id) => id.compute_digest(),
-        }
-    }
-}
-
 impl LiteralIdentifier {
     pub fn compute_digest(&mut self) -> Digest {
         match self {
@@ -228,7 +219,7 @@ impl PrimitiveType {
         let mut hasher = Sha256::new();
         match self {
             PrimitiveType::Any => hasher.update(b"any"),
-            PrimitiveType::Named(id) => hasher.update(id.compute_digest()),
+            PrimitiveType::Named { id } => hasher.update(id.compute_digest()),
             PrimitiveType::String => hasher.update(b"string"),
             PrimitiveType::Number(suffix) => hasher.update(suffix.digestable_id()),
             PrimitiveType::Boolean => hasher.update(b"bool"),

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

@@ -2,7 +2,7 @@ pub(crate) mod digest;
 pub mod types;
 
 use crate::{
-    parsing::ast::types::{BinaryPart, BodyItem, Expr, LiteralIdentifier, MemberObject},
+    parsing::ast::types::{BinaryPart, BodyItem, Expr, LiteralIdentifier},
     ModuleId,
 };
 
@@ -57,15 +57,6 @@ impl BinaryPart {
     }
 }
 
-impl MemberObject {
-    pub fn module_id(&self) -> ModuleId {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.module_id,
-            MemberObject::Identifier(identifier) => identifier.module_id,
-        }
-    }
-}
-
 impl LiteralIdentifier {
     pub fn module_id(&self) -> ModuleId {
         match self {

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

@@ -25,7 +25,6 @@ pub use crate::parsing::ast::types::{
     none::KclNone,
 };
 use crate::{
-    docs::StdLibFn,
     errors::KclError,
     execution::{
         annotations,
@@ -454,7 +453,7 @@ impl Node<Program> {
                         alpha: c.a,
                     },
                 };
-                if colors.borrow().iter().any(|c| *c == color) {
+                if colors.borrow().contains(&color) {
                     return;
                 }
                 colors.borrow_mut().push(color);
@@ -529,7 +528,7 @@ impl Node<Program> {
         let new_color = csscolorparser::Color::new(color.red, color.green, color.blue, color.alpha);
         Ok(Some(ColorPresentation {
             // The label will be what they replace the color with.
-            label: new_color.to_hex_string(),
+            label: new_color.to_css_hex(),
             text_edit: None,
             additional_text_edits: None,
         }))
@@ -1973,31 +1972,6 @@ impl CallExpressionKw {
     }
 }
 
-/// A function declaration.
-#[derive(Debug, Clone, Default, Serialize, Deserialize, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(tag = "type")]
-pub enum Function {
-    /// A stdlib function written in Rust (aka core lib).
-    StdLib {
-        /// The function.
-        func: Box<dyn StdLibFn>,
-    },
-    /// A function that is defined in memory.
-    #[default]
-    InMemory,
-}
-
-impl PartialEq for Function {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Function::StdLib { func: func1 }, Function::StdLib { func: func2 }) => func1.name() == func2.name(),
-            (Function::InMemory, Function::InMemory) => true,
-            _ => false,
-        }
-    }
-}
-
 #[derive(Debug, Default, Clone, Copy, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
@@ -2782,47 +2756,6 @@ impl ObjectProperty {
     }
 }
 
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
-#[ts(export)]
-#[serde(tag = "type")]
-pub enum MemberObject {
-    MemberExpression(BoxNode<MemberExpression>),
-    Identifier(BoxNode<Identifier>),
-}
-
-impl MemberObject {
-    pub fn start(&self) -> usize {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.start,
-            MemberObject::Identifier(identifier) => identifier.start,
-        }
-    }
-
-    pub fn end(&self) -> usize {
-        match self {
-            MemberObject::MemberExpression(member_expression) => member_expression.end,
-            MemberObject::Identifier(identifier) => identifier.end,
-        }
-    }
-
-    pub(crate) fn contains_range(&self, range: &SourceRange) -> bool {
-        let sr = SourceRange::from(self);
-        sr.contains_range(range)
-    }
-}
-
-impl From<MemberObject> for SourceRange {
-    fn from(obj: MemberObject) -> Self {
-        Self::new(obj.start(), obj.end(), obj.module_id())
-    }
-}
-
-impl From<&MemberObject> for SourceRange {
-    fn from(obj: &MemberObject) -> Self {
-        Self::new(obj.start(), obj.end(), obj.module_id())
-    }
-}
-
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
 #[ts(export)]
 #[serde(tag = "type")]
@@ -2868,7 +2801,7 @@ impl From<&LiteralIdentifier> for SourceRange {
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct MemberExpression {
-    pub object: MemberObject,
+    pub object: Expr,
     pub property: LiteralIdentifier,
     pub computed: bool,
 
@@ -2890,12 +2823,7 @@ impl Node<MemberExpression> {
 impl MemberExpression {
     /// Rename all identifiers that have the old name to the new given name.
     fn rename_identifiers(&mut self, old_name: &str, new_name: &str) {
-        match &mut self.object {
-            MemberObject::MemberExpression(ref mut member_expression) => {
-                member_expression.rename_identifiers(old_name, new_name)
-            }
-            MemberObject::Identifier(ref mut identifier) => identifier.rename(old_name, new_name),
-        }
+        self.object.rename_identifiers(old_name, new_name);
 
         match &mut self.property {
             LiteralIdentifier::Identifier(ref mut identifier) => identifier.rename(old_name, new_name),
@@ -3230,7 +3158,7 @@ pub enum PrimitiveType {
     /// `fn`, type of functions.
     Function(FunctionType),
     /// An identifier used as a type (not really a primitive type, but whatever).
-    Named(Node<Identifier>),
+    Named { id: Node<Identifier> },
 }
 
 impl PrimitiveType {
@@ -3286,7 +3214,7 @@ impl fmt::Display for PrimitiveType {
                 }
                 Ok(())
             }
-            PrimitiveType::Named(n) => write!(f, "{}", n.name),
+            PrimitiveType::Named { id: n } => write!(f, "{}", n.name),
         }
     }
 }

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

@@ -1,6 +1,6 @@
 use serde::Serialize;
 
-use super::{BodyItem, Expr, MemberObject, Node, Program};
+use super::{BodyItem, Expr, Node, Program};
 use crate::SourceRange;
 
 /// A traversal path through the AST to a node.
@@ -60,6 +60,20 @@ pub enum Step {
 }
 
 impl NodePath {
+    /// Placeholder for when the AST isn't available to create a real path.  It
+    /// will be filled in later.
+    pub(crate) fn placeholder() -> Self {
+        Self::default()
+    }
+
+    #[cfg(feature = "artifact-graph")]
+    pub(crate) fn fill_placeholder(&mut self, program: &Node<Program>, cached_body_items: usize, range: SourceRange) {
+        if !self.is_empty() {
+            return;
+        }
+        *self = Self::from_range(program, cached_body_items, range).unwrap_or_default();
+    }
+
     /// Given a program and a [`SourceRange`], return the path to the node that
     /// contains the range.
     pub(crate) fn from_range(program: &Node<Program>, cached_body_items: usize, range: SourceRange) -> Option<Self> {
@@ -248,7 +262,7 @@ impl NodePath {
             Expr::MemberExpression(node) => {
                 if node.object.contains_range(&range) {
                     path.push(Step::MemberExpressionObject);
-                    return Self::from_member_expr_object(&node.object, range, path);
+                    return NodePath::from_expr(&node.object, range, path);
                 }
                 if node.property.contains_range(&range) {
                     path.push(Step::MemberExpressionProperty);
@@ -313,18 +327,6 @@ impl NodePath {
         Some(path)
     }
 
-    fn from_member_expr_object(mut expr: &MemberObject, range: SourceRange, mut path: NodePath) -> Option<NodePath> {
-        while let MemberObject::MemberExpression(node) = expr {
-            if !node.object.contains_range(&range) {
-                break;
-            }
-            path.push(Step::MemberExpressionObject);
-            expr = &node.object;
-        }
-
-        Some(path)
-    }
-
     pub fn is_empty(&self) -> bool {
         self.steps.is_empty()
     }
@@ -402,4 +404,19 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_node_path_from_range_import() {
+        let code = r#"import "cube.step" as cube
+import "cylinder.kcl" as cylinder
+"#;
+        let program = crate::Program::parse_no_errs(code).unwrap();
+        // The entire cylinder import statement.
+        assert_eq!(
+            NodePath::from_range(&program.ast, 0, range(27, 60)).unwrap(),
+            NodePath {
+                steps: vec![Step::ProgramBodyItem { index: 1 }],
+            }
+        );
+    }
 }

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

@@ -26,8 +26,8 @@ use crate::{
             Annotation, ArrayExpression, ArrayRangeExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem,
             BoxNode, CallExpressionKw, CommentStyle, DefaultParamVal, ElseIf, Expr, ExpressionStatement,
             FunctionExpression, FunctionType, Identifier, IfExpression, ImportItem, ImportSelector, ImportStatement,
-            ItemVisibility, LabeledArg, Literal, LiteralIdentifier, LiteralValue, MemberExpression, MemberObject, Name,
-            Node, NodeList, NonCodeMeta, NonCodeNode, NonCodeValue, ObjectExpression, ObjectProperty, Parameter,
+            ItemVisibility, LabeledArg, Literal, LiteralIdentifier, LiteralValue, MemberExpression, Name, Node,
+            NodeList, NonCodeMeta, NonCodeNode, NonCodeValue, ObjectExpression, ObjectProperty, Parameter,
             PipeExpression, PipeSubstitution, PrimitiveType, Program, ReturnStatement, Shebang, TagDeclarator, Type,
             TypeDeclaration, UnaryExpression, UnaryOperator, VariableDeclaration, VariableDeclarator, VariableKind,
         },
@@ -1326,10 +1326,7 @@ fn member_expression_subscript(i: &mut TokenSlice) -> ModalResult<(LiteralIdenti
 
 /// Get a property of an object, or an index of an array, or a member of a collection.
 /// Can be arbitrarily nested, e.g. `people[i]['adam'].age`.
-fn member_expression(i: &mut TokenSlice) -> ModalResult<Node<MemberExpression>> {
-    // This is an identifier, followed by a sequence of members (aka properties)
-    // First, the identifier.
-    let id = nameable_identifier.context(expected("the identifier of the object whose property you're trying to access, e.g. in 'shape.size.width', 'shape' is the identifier")).parse_next(i)?;
+fn build_member_expression(object: Expr, i: &mut TokenSlice) -> ModalResult<Node<MemberExpression>> {
     // Now a sequence of members.
     let member = alt((member_expression_dot, member_expression_subscript)).context(expected("a member/property, e.g. size.x and size['height'] and size[0] are all different ways to access a member/property of 'size'"));
     let mut members: Vec<_> = repeat(1.., member)
@@ -1340,11 +1337,11 @@ fn member_expression(i: &mut TokenSlice) -> ModalResult<Node<MemberExpression>>
     // It's safe to call remove(0), because the vec is created from repeat(1..),
     // which is guaranteed to have >=1 elements.
     let (property, end, computed) = members.remove(0);
-    let start = id.start;
-    let module_id = id.module_id;
+    let start = object.start();
+    let module_id = object.module_id();
     let initial_member_expression = Node::new(
         MemberExpression {
-            object: MemberObject::Identifier(Box::new(id)),
+            object,
             computed,
             property,
             digest: None,
@@ -1362,7 +1359,7 @@ fn member_expression(i: &mut TokenSlice) -> ModalResult<Node<MemberExpression>>
         .fold(initial_member_expression, |accumulated, (property, end, computed)| {
             Node::new(
                 MemberExpression {
-                    object: MemberObject::MemberExpression(Box::new(accumulated)),
+                    object: Expr::MemberExpression(Box::new(accumulated)),
                     computed,
                     property,
                     digest: None,
@@ -2085,8 +2082,7 @@ fn unnecessarily_bracketed(i: &mut TokenSlice) -> ModalResult<Expr> {
 }
 
 fn expr_allowed_in_pipe_expr(i: &mut TokenSlice) -> ModalResult<Expr> {
-    alt((
-        member_expression.map(Box::new).map(Expr::MemberExpression),
+    let parsed_expr = alt((
         bool_value.map(Box::new).map(Expr::Literal),
         tag.map(Box::new).map(Expr::TagDeclarator),
         literal.map(Expr::Literal),
@@ -2100,14 +2096,19 @@ fn expr_allowed_in_pipe_expr(i: &mut TokenSlice) -> ModalResult<Expr> {
         unnecessarily_bracketed,
     ))
     .context(expected("a KCL expression (but not a pipe expression)"))
-    .parse_next(i)
+    .parse_next(i)?;
+
+    let maybe_member = build_member_expression(parsed_expr.clone(), i);
+    if let Ok(mem) = maybe_member {
+        return Ok(Expr::MemberExpression(Box::new(mem)));
+    }
+    Ok(parsed_expr)
 }
 
 fn possible_operands(i: &mut TokenSlice) -> ModalResult<Expr> {
     let mut expr = alt((
         unary_expression.map(Box::new).map(Expr::UnaryExpression),
         bool_value.map(Box::new).map(Expr::Literal),
-        member_expression.map(Box::new).map(Expr::MemberExpression),
         literal.map(Expr::Literal),
         fn_call_kw.map(Box::new).map(Expr::CallExpressionKw),
         name.map(Box::new).map(Expr::Name),
@@ -2118,6 +2119,10 @@ fn possible_operands(i: &mut TokenSlice) -> ModalResult<Expr> {
         "a KCL value which can be used as an argument/operand to an operator",
     ))
     .parse_next(i)?;
+    let maybe_member = build_member_expression(expr.clone(), i);
+    if let Ok(mem) = maybe_member {
+        expr = Expr::MemberExpression(Box::new(mem));
+    }
 
     let ty = opt((colon, opt(whitespace), type_)).parse_next(i)?;
     if let Some((_, _, ty)) = ty {
@@ -2480,32 +2485,13 @@ impl TryFrom<Token> for Node<TagDeclarator> {
     }
 }
 
-impl Node<TagDeclarator> {
-    fn into_valid_binding_name(self) -> Result<Self, CompilationError> {
-        // Make sure they are not assigning a variable to a stdlib function.
-        if crate::std::name_in_stdlib(&self.name) {
-            return Err(CompilationError::fatal(
-                SourceRange::from(&self),
-                format!("Cannot assign a tag to a reserved keyword: {}", self.name),
-            ));
-        }
-        Ok(self)
-    }
-}
-
 /// Parse a Kcl tag that starts with a `$`.
 fn tag(i: &mut TokenSlice) -> ModalResult<Node<TagDeclarator>> {
     dollar.parse_next(i)?;
-    let tag_declarator = any
-        .try_map(Node::<TagDeclarator>::try_from)
+    any.try_map(Node::<TagDeclarator>::try_from)
         .context(expected("a tag, e.g. '$seg01' or '$line01'"))
         .parse_next(i)
-        .map_err(|e: ErrMode<ContextError>| e.cut())?;
-    // Now that we've parsed a tag declarator, verify that it's not a stdlib
-    // name.  If it is, stop backtracking.
-    tag_declarator
-        .into_valid_binding_name()
-        .map_err(|e| ErrMode::Cut(ContextError::from(e)))
+        .map_err(|e: ErrMode<ContextError>| e.cut())
 }
 
 /// Helper function. Matches any number of whitespace tokens and ignores them.
@@ -2938,7 +2924,7 @@ fn primitive_type(i: &mut TokenSlice) -> ModalResult<Node<PrimitiveType>> {
         (identifier, opt(delimited(open_paren, uom_for_type, close_paren))).map(|(ident, suffix)| {
             let mut result = Node::new(PrimitiveType::Boolean, ident.start, ident.end, ident.module_id);
             result.inner =
-                PrimitiveType::primitive_from_str(&ident.name, suffix).unwrap_or(PrimitiveType::Named(ident));
+                PrimitiveType::primitive_from_str(&ident.name, suffix).unwrap_or(PrimitiveType::Named { id: ident });
             result
         }),
     ))
@@ -3277,7 +3263,7 @@ fn fn_call_kw(i: &mut TokenSlice) -> ModalResult<Node<CallExpressionKw>> {
                 return Err(ErrMode::Cut(
                     CompilationError::fatal(
                         SourceRange::from(&tok),
-                        format!("There was an unexpected {}. Try removing it.", tok.value),
+                        format!("There was an unexpected `{}`. Try removing it.", tok.value),
                     )
                     .into(),
                 ));
@@ -4446,7 +4432,7 @@ z(-[["#,
         assert_err(
             r#"z
 (--#"#,
-            "There was an unexpected -. Try removing it.",
+            "There was an unexpected `-`. Try removing it.",
             [3, 4],
         );
     }
@@ -4898,19 +4884,6 @@ let myBox = box(p=[0,0], h=-3, l=-16, w=-10)
         }
     }
 
-    #[test]
-    fn test_parse_tag_named_std_lib() {
-        let some_program_string = r#"startSketchOn(XY)
-    |> startProfile(at = [0, 0])
-    |> line(%, end = [5, 5], tag = $xLine)
-"#;
-        assert_err(
-            some_program_string,
-            "Cannot assign a tag to a reserved keyword: xLine",
-            [86, 92],
-        );
-    }
-
     #[test]
     fn test_parse_empty_tag_brace() {
         let some_program_string = r#"startSketchOn(XY)
@@ -5029,6 +5002,17 @@ type foo = fn(fn, f: fn(number(_))): [fn([any]): string]
         assert_no_err(some_program_string);
     }
 
+    #[test]
+    fn test_parse_fn_call_then_field() {
+        let some_program_string = "myFunction().field";
+        let module_id = ModuleId::default();
+        let tokens = crate::parsing::token::lex(some_program_string, module_id).unwrap(); // Updated import path
+        let actual = expression.parse(tokens.as_slice()).unwrap();
+        let Expr::MemberExpression(_expr) = actual else {
+            panic!("expected member expression")
+        };
+    }
+
     #[test]
     fn test_parse_array_missing_closing_bracket() {
         let some_program_string = r#"
@@ -5217,7 +5201,7 @@ bar = 1
             .cause
             .as_ref()
             .expect("Found an error, but there was no cause. Add a cause.");
-        assert_eq!(cause.message, "There was an unexpected }. Try removing it.",);
+        assert_eq!(cause.message, "There was an unexpected `}`. Try removing it.",);
         assert_eq!(cause.source_range.start(), expected_src_start);
     }
 

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

@@ -117,12 +117,20 @@ expression: actual
             "computed": false,
             "end": 45,
             "object": {
+              "abs_path": false,
               "commentStart": 40,
               "end": 43,
-              "name": "obj",
+              "name": {
+                "commentStart": 40,
+                "end": 43,
+                "name": "obj",
+                "start": 40,
+                "type": "Identifier"
+              },
+              "path": [],
               "start": 40,
-              "type": "Identifier",
-              "type": "Identifier"
+              "type": "Name",
+              "type": "Name"
             },
             "property": {
               "commentStart": 44,

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

@@ -117,12 +117,20 @@ expression: actual
             "computed": false,
             "end": 49,
             "object": {
+              "abs_path": false,
               "commentStart": 41,
               "end": 44,
-              "name": "obj",
+              "name": {
+                "commentStart": 41,
+                "end": 44,
+                "name": "obj",
+                "start": 41,
+                "type": "Identifier"
+              },
+              "path": [],
               "start": 41,
-              "type": "Identifier",
-              "type": "Identifier"
+              "type": "Name",
+              "type": "Name"
             },
             "property": {
               "commentStart": 45,

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

@@ -104,12 +104,20 @@ expression: actual
             "computed": false,
             "end": 44,
             "object": {
+              "abs_path": false,
               "commentStart": 36,
               "end": 39,
-              "name": "obj",
+              "name": {
+                "commentStart": 36,
+                "end": 39,
+                "name": "obj",
+                "start": 36,
+                "type": "Identifier"
+              },
+              "path": [],
               "start": 36,
-              "type": "Identifier",
-              "type": "Identifier"
+              "type": "Name",
+              "type": "Name"
             },
             "property": {
               "commentStart": 40,

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

@@ -120,12 +120,20 @@ expression: actual
                 "computed": false,
                 "end": 49,
                 "object": {
+                  "abs_path": false,
                   "commentStart": 41,
                   "end": 44,
-                  "name": "obj",
+                  "name": {
+                    "commentStart": 41,
+                    "end": 44,
+                    "name": "obj",
+                    "start": 41,
+                    "type": "Identifier"
+                  },
+                  "path": [],
                   "start": 41,
-                  "type": "Identifier",
-                  "type": "Identifier"
+                  "type": "Name",
+                  "type": "Name"
                 },
                 "property": {
                   "commentStart": 45,

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

@@ -107,12 +107,20 @@ expression: actual
                 "computed": false,
                 "end": 45,
                 "object": {
+                  "abs_path": false,
                   "commentStart": 37,
                   "end": 40,
-                  "name": "obj",
+                  "name": {
+                    "commentStart": 37,
+                    "end": 40,
+                    "name": "obj",
+                    "start": 37,
+                    "type": "Identifier"
+                  },
+                  "path": [],
                   "start": 37,
-                  "type": "Identifier",
-                  "type": "Identifier"
+                  "type": "Name",
+                  "type": "Name"
                 },
                 "property": {
                   "commentStart": 41,

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

@@ -107,12 +107,20 @@ expression: actual
                 "computed": false,
                 "end": 44,
                 "object": {
+                  "abs_path": false,
                   "commentStart": 36,
                   "end": 39,
-                  "name": "obj",
+                  "name": {
+                    "commentStart": 36,
+                    "end": 39,
+                    "name": "obj",
+                    "start": 36,
+                    "type": "Identifier"
+                  },
+                  "path": [],
                   "start": 36,
-                  "type": "Identifier",
-                  "type": "Identifier"
+                  "type": "Name",
+                  "type": "Name"
                 },
                 "property": {
                   "commentStart": 40,

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

@@ -37,12 +37,20 @@ expression: actual
             "computed": false,
             "end": 18,
             "object": {
+              "abs_path": false,
               "commentStart": 13,
               "end": 16,
-              "name": "obj",
+              "name": {
+                "commentStart": 13,
+                "end": 16,
+                "name": "obj",
+                "start": 13,
+                "type": "Identifier"
+              },
+              "path": [],
               "start": 13,
-              "type": "Identifier",
-              "type": "Identifier"
+              "type": "Name",
+              "type": "Name"
             },
             "property": {
               "commentStart": 17,

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

@@ -24,12 +24,20 @@ expression: actual
               "computed": false,
               "end": 19,
               "object": {
+                "abs_path": false,
                 "commentStart": 11,
                 "end": 14,
-                "name": "obj",
+                "name": {
+                  "commentStart": 11,
+                  "end": 14,
+                  "name": "obj",
+                  "start": 11,
+                  "type": "Identifier"
+                },
+                "path": [],
                 "start": 11,
-                "type": "Identifier",
-                "type": "Identifier"
+                "type": "Name",
+                "type": "Name"
               },
               "property": {
                 "commentStart": 15,

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

@@ -101,12 +101,20 @@ expression: actual
           "computed": false,
           "end": 44,
           "object": {
+            "abs_path": false,
             "commentStart": 36,
             "end": 39,
-            "name": "obj",
+            "name": {
+              "commentStart": 36,
+              "end": 39,
+              "name": "obj",
+              "start": 36,
+              "type": "Identifier"
+            },
+            "path": [],
             "start": 36,
-            "type": "Identifier",
-            "type": "Identifier"
+            "type": "Name",
+            "type": "Name"
           },
           "property": {
             "commentStart": 40,

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

@@ -25,12 +25,20 @@ expression: actual
             "computed": false,
             "end": 16,
             "object": {
+              "abs_path": false,
               "commentStart": 7,
               "end": 9,
-              "name": "yo",
+              "name": {
+                "commentStart": 7,
+                "end": 9,
+                "name": "yo",
+                "start": 7,
+                "type": "Identifier"
+              },
+              "path": [],
               "start": 7,
-              "type": "Identifier",
-              "type": "Identifier"
+              "type": "Name",
+              "type": "Name"
             },
             "property": {
               "commentStart": 10,

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

@@ -21,12 +21,20 @@ expression: actual
           "computed": true,
           "end": 11,
           "object": {
+            "abs_path": false,
             "commentStart": 6,
             "end": 8,
-            "name": "b1",
+            "name": {
+              "commentStart": 6,
+              "end": 8,
+              "name": "b1",
+              "start": 6,
+              "type": "Identifier"
+            },
+            "path": [],
             "start": 6,
-            "type": "Identifier",
-            "type": "Identifier"
+            "type": "Name",
+            "type": "Name"
           },
           "property": {
             "commentStart": 9,

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

@@ -33,12 +33,20 @@ expression: actual
                 "computed": false,
                 "end": 13,
                 "object": {
+                  "abs_path": false,
                   "commentStart": 7,
                   "end": 9,
-                  "name": "yo",
+                  "name": {
+                    "commentStart": 7,
+                    "end": 9,
+                    "name": "yo",
+                    "start": 7,
+                    "type": "Identifier"
+                  },
+                  "path": [],
                   "start": 7,
-                  "type": "Identifier",
-                  "type": "Identifier"
+                  "type": "Name",
+                  "type": "Name"
                 },
                 "property": {
                   "commentStart": 10,