Cut release v0.12.0 (#1069 )

Fit resolutions to less than 2k x 2k (#1065 )
* Fit resolutions to less than 2k x 2k * Integer resolutions * Scale mouse clicks * Move stream maxResolution logic to getDimensions
2023-11-13 21:11:38 -05:00 · 2023-11-13 19:32:07 -05:00 · 2023-11-14 06:13:15 +11:00 · 2023-11-13 13:08:16 -06:00 · 2023-11-13 05:13:28 -05:00 · 2023-11-13 05:13:16 -05:00
85 changed files with 2035 additions and 22827 deletions
--- a/.eslintrc
+++ b/.eslintrc
@ -11,6 +11,7 @@
      "semi": [
        "error",
        "never"
-      ]
+      ],
+      "react-hooks/exhaustive-deps": "off"
    }
 }
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -12,9 +12,13 @@ on:
  # Daily at 04:00 AM UTC
  # Will checkout the last commit from the default branch (main as of 2023-10-04)

+env:
+  BUILD_RELEASE: ${{ github.event_name == 'release' || github.event_name == 'schedule' || github.event_name == 'pull_request' && contains(github.event.pull_request.title, 'Cut release v') }}
+
 concurrency:
  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
  cancel-in-progress: true
+
 jobs:
  check-format:
    runs-on: 'ubuntu-latest'
@ -46,6 +50,20 @@ jobs:
      - run: yarn tsc


+  check-typos: 
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v4
+      - name: Install codespell
+        run: |
+            python -m pip install codespell
+      - name: Run codespell
+        run: codespell --config .codespellrc # Edit this file to tweak the typo list and other configuration.
+
+
  build-test-web:
    runs-on: ubuntu-latest
    steps:
@ -88,7 +106,7 @@ jobs:
        run: |
          VERSION=$(date +'%-y.%-m.%-d') yarn bump-jsons
          echo "$(jq --arg url 'https://dl.kittycad.io/releases/modeling-app/nightly/last_update.json' \
-            '.tauri.updater.endpoints[]=$url' src-tauri/tauri.conf.json --indent 2)" > src-tauri/tauri.conf.json
+            '.tauri.updater.endpoints[]=$url' src-tauri/tauri.release.conf.json --indent 2)" > src-tauri/tauri.release.conf.json

      - uses: actions/upload-artifact@v3
        if: github.event_name == 'schedule'
@ -96,13 +114,14 @@ jobs:
          path: |
            package.json
            src-tauri/tauri.conf.json
+            src-tauri/tauri.release.conf.json

      - id: export_version
        run: echo "version=`cat package.json | jq -r '.version'`" >> "$GITHUB_OUTPUT"


  build-test-apps:
-    needs: [check-format, build-test-web, prepare-json-files, check-types]
+    needs: [prepare-json-files]
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
@ -118,8 +137,9 @@ jobs:
          ls -l artifact
          cp artifact/package.json package.json
          cp artifact/src-tauri/tauri.conf.json src-tauri/tauri.conf.json
+          cp artifact/src-tauri/tauri.release.conf.json src-tauri/tauri.release.conf.json 

-      - name: install ubuntu system dependencies
+      - name: Install ubuntu system dependencies
        if: matrix.os == 'ubuntu-latest'
        run: >
          sudo apt-get update &&
@ -139,10 +159,10 @@ jobs:

      - run: yarn install

-      - name: Rust setup
+      - name: Setup Rust
        uses: dtolnay/rust-toolchain@stable

-      - name: Rust cache
+      - name: Setup Rust cache
        uses: swatinem/rust-cache@v2
        with:
          workspaces: './src-tauri -> target'
@ -151,24 +171,27 @@ jobs:
        with:
          workspaces: './src/wasm-lib'

-      - name: wasm prep
+      - name: Run build:wasm manually
        shell: bash
+        env:
+          MODE: ${{ env.BUILD_RELEASE == 'true' && '--release' || '--debug' }}
        run: |
          mkdir src/wasm-lib/pkg; cd src/wasm-lib
-          npx wasm-pack build --target web --out-dir pkg
+          echo "building with ${{ env.MODE }}"
+          npx wasm-pack build --target web --out-dir pkg ${{ env.MODE }}
          cd ../../
          cp src/wasm-lib/pkg/wasm_lib_bg.wasm public

      - name: Fix format
        run: yarn fmt

-      - name: install apple silicon target mac
+      - name: Install Universal target (MacOS only)
        if: matrix.os == 'macos-latest'
        run: |
          rustup target add aarch64-apple-darwin

-      - name: Prepare Windows certificate and variables
-        if: matrix.os == 'windows-latest'
+      - name: Prepare certificate and variables (Windows only)
+        if: ${{ matrix.os == 'windows-latest' && env.BUILD_RELEASE == 'true' }}
        run: |
          echo "${{secrets.SM_CLIENT_CERT_FILE_B64 }}" | base64 --decode > /d/Certificate_pkcs12.p12
          cat /d/Certificate_pkcs12.p12
@ -182,8 +205,8 @@ jobs:
          echo "C:\Program Files\DigiCert\DigiCert One Signing Manager Tools" >> $GITHUB_PATH
        shell: bash

-      - name: Setup Windows certicate with SSM KSP
-        if: matrix.os == 'windows-latest'
+      - name: Setup certicate with SSM KSP (Windows only)
+        if: ${{ matrix.os == 'windows-latest' && env.BUILD_RELEASE == 'true' }}
        run: |
          curl -X GET  https://one.digicert.com/signingmanager/api-ui/v1/releases/smtools-windows-x64.msi/download -H "x-api-key:%SM_API_KEY%" -o smtools-windows-x64.msi
          msiexec /i smtools-windows-x64.msi /quiet /qn
@ -193,8 +216,17 @@ jobs:
          smksp_cert_sync.exe
        shell: cmd

-      - name: Build and sign the app for the current platform
+      - name: Build the app (debug)
        uses: tauri-apps/tauri-action@v0
+        if: ${{ env.BUILD_RELEASE == 'false' }}
+        with:
+          includeRelease: false
+          includeDebug: true
+          args: ${{ matrix.os == 'macos-latest' && '--target universal-apple-darwin' || '' }}
+
+      - name: Build the app (release) and sign
+        uses: tauri-apps/tauri-action@v0
+        if: ${{ env.BUILD_RELEASE == 'true' }}
        env:
          TAURI_PRIVATE_KEY: ${{ secrets.TAURI_PRIVATE_KEY }}
          TAURI_KEY_PASSWORD: ${{ secrets.TAURI_KEY_PASSWORD }}
@ -204,34 +236,35 @@ jobs:
          APPLE_ID: ${{ secrets.APPLE_ID }}
          APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
          APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          TAURI_CONF_ARGS: "--config ${{ matrix.os == 'windows-latest' && 'src-tauri\\tauri.release.conf.json' || 'src-tauri/tauri.release.conf.json' }}"
        with:
-          args: ${{ matrix.os == 'macos-latest' && '--target universal-apple-darwin' || '' }}
+          args: "${{ matrix.os == 'macos-latest' && '--target universal-apple-darwin' || '' }} ${{ env.TAURI_CONF_ARGS }}"

      - uses: actions/upload-artifact@v3
+        env:
+          PREFIX: ${{ matrix.os == 'macos-latest' && 'src-tauri/target/universal-apple-darwin' || 'src-tauri/target' }}
+          MODE: ${{ env.BUILD_RELEASE == 'true' && 'release' || 'debug' }}
        with:
-          path: ${{ matrix.os == 'macos-latest' && 'src-tauri/target/universal-apple-darwin/release/bundle/*/*' || 'src-tauri/target/release/bundle/*/*' }}
+          path: "${{ env.PREFIX }}/${{ env.MODE }}/bundle/*/*"

-      - name: Install tauri-driver for e2e tests
+      - name: Install tauri-driver for e2e tests (linux only)
        if: matrix.os == 'ubuntu-latest'
        uses: actions-rs/cargo@v1
        with:
          command: install
          args: tauri-driver

-      - name: Run e2e tests
+      - name: Run e2e tests (linux only)
        if: matrix.os == 'ubuntu-latest'
        run: xvfb-run yarn test:e2e
+        env:
+          MODE: ${{ env.BUILD_RELEASE == 'true' && 'release' || 'debug' }}

-  typos: # Edit .codespellrc to change this CI job's configuration.
-    runs-on: ubuntu-latest
-    steps:
-    - name: Check for typos
-      uses: codespell-project/actions-codespell@v2

  publish-apps-release:
    runs-on: ubuntu-latest
    if: ${{ github.event_name == 'release' || github.event_name == 'schedule' }}
-    needs: [build-test-web, prepare-json-files, build-test-apps]
+    needs: [check-format, check-types, check-typos, build-test-web, prepare-json-files, build-test-apps]
    env:
      VERSION_NO_V: ${{ needs.prepare-json-files.outputs.version }}
      VERSION: ${{ github.event_name == 'release' && format('v{0}', needs.prepare-json-files.outputs.version) || needs.prepare-json-files.outputs.version }}
--- a/README.md
+++ b/README.md
@ -48,7 +48,7 @@ We recommend downloading the latest application binary from [our Releases page](

 ## Running a development build

-First, [install Rust via `rustup`](https://www.rust-lang.org/tools/install). This project uses a lot of Rust compiled to [WASM](https://webassembly.org/) within it. Then, run:
+First, [install Rust via `rustup`](https://www.rust-lang.org/tools/install). This project uses a lot of Rust compiled to [WASM](https://webassembly.org/) within it. We always use the latest stable version of Rust, so you may need to run `rustup update stable`. Then, run:

 ```
 yarn install
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "untitled-app",
-  "version": "0.11.1",
+  "version": "0.12.0",
  "private": true,
  "dependencies": {
    "@codemirror/autocomplete": "^6.10.2",
@ -8,15 +8,15 @@
    "@fortawesome/free-brands-svg-icons": "^6.4.2",
    "@fortawesome/free-solid-svg-icons": "^6.4.2",
    "@fortawesome/react-fontawesome": "^0.2.0",
-    "@headlessui/react": "^1.7.13",
+    "@headlessui/react": "^1.7.17",
    "@headlessui/tailwindcss": "^0.2.0",
    "@kittycad/lib": "^0.0.45",
    "@lezer/javascript": "^1.4.7",
    "@open-rpc/client-js": "^1.8.1",
    "@react-hook/resize-observer": "^1.2.6",
    "@replit/codemirror-interact": "^6.3.0",
-    "@sentry/react": "^7.65.0",
-    "@tauri-apps/api": "^1.5.0",
+    "@sentry/react": "^7.77.0",
+    "@tauri-apps/api": "^1.5.1",
    "@testing-library/jest-dom": "^5.14.1",
    "@testing-library/react": "^14.0.0",
    "@testing-library/user-event": "^14.5.1",
@ -30,7 +30,7 @@
    "crypto-js": "^4.2.0",
    "debounce-promise": "^3.1.2",
    "formik": "^2.4.3",
-    "fuse.js": "^6.6.2",
+    "fuse.js": "^7.0.0",
    "http-server": "^14.1.1",
    "json-rpc-2.0": "^1.6.0",
    "re-resizable": "^6.9.11",
@ -51,7 +51,7 @@
    "uuid": "^9.0.1",
    "vitest": "^0.34.6",
    "vscode-jsonrpc": "^8.1.0",
-    "vscode-languageserver-protocol": "^3.17.3",
+    "vscode-languageserver-protocol": "^3.17.5",
    "wasm-pack": "^0.12.1",
    "web-vitals": "^3.5.0",
    "ws": "^8.13.0",
@ -102,7 +102,7 @@
  },
  "devDependencies": {
    "@babel/plugin-proposal-private-property-in-object": "^7.21.11",
-    "@babel/preset-env": "^7.22.9",
+    "@babel/preset-env": "^7.23.3",
    "@tauri-apps/cli": "^1.5.6",
    "@types/crypto-js": "^4.1.1",
    "@types/debounce-promise": "^3.1.8",
@ -111,18 +111,18 @@
    "@types/uuid": "^9.0.4",
    "@types/wicg-file-system-access": "^2020.9.6",
    "@types/ws": "^8.5.5",
-    "@vitejs/plugin-react": "^4.0.3",
+    "@vitejs/plugin-react": "^4.1.1",
    "@vitest/coverage-istanbul": "^0.34.1",
    "autoprefixer": "^10.4.13",
-    "eslint": "^8.44.0",
+    "eslint": "^8.53.0",
    "eslint-config-react-app": "^7.0.1",
-    "eslint-plugin-css-modules": "^2.11.0",
+    "eslint-plugin-css-modules": "^2.12.0",
    "happy-dom": "^10.8.0",
    "husky": "^8.0.3",
    "postcss": "^8.4.31",
    "prettier": "^2.8.0",
    "setimmediate": "^1.0.5",
-    "tailwindcss": "^3.2.4",
+    "tailwindcss": "^3.3.5",
    "vite": "^4.5.0",
    "vite-plugin-eslint": "^1.8.1",
    "vite-tsconfig-paths": "^4.2.1",
--- a/src-tauri/Cargo.lock
+++ b/src-tauri/Cargo.lock
@ -1732,9 +1732,9 @@ checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"

 [[package]]
 name = "libc"
-version = "0.2.148"
+version = "0.2.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
+checksum = "89d92a4743f9a61002fae18374ed11e7973f530cb3a3255fb354818118b2203c"

 [[package]]
 name = "libm"
@ -1913,12 +1913,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"

-[[package]]
-name = "minisign-verify"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "933dca44d65cdd53b355d0b73d380a2ff5da71f87f036053188bf1eab6a19881"
-
 [[package]]
 name = "miniz_oxide"
 version = "0.6.2"
@ -1940,9 +1934,9 @@ dependencies = [

 [[package]]
 name = "mio"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
+checksum = "3dce281c5e46beae905d4de1870d8b1509a9142b62eedf18b443b011ca8343d0"
 dependencies = [
 "libc",
 "wasi 0.11.0+wasi-snapshot-preview1",
@ -3215,9 +3209,9 @@ dependencies = [

 [[package]]
 name = "serde"
-version = "1.0.190"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7"
+checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001"
 dependencies = [
 "serde_derive",
 ]
@ -3233,9 +3227,9 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.190"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3"
+checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1"
 dependencies = [
 "proc-macro2",
 "quote",
@ -3438,9 +3432,9 @@ dependencies = [

 [[package]]
 name = "socket2"
-version = "0.5.4"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4031e820eb552adee9295814c0ced9e5cf38ddf1e8b7d566d6de8e2538ea989e"
+checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
 dependencies = [
 "libc",
 "windows-sys 0.48.0",
@ -3745,7 +3739,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9bfe673cf125ef364d6f56b15e8ce7537d9ca7e4dae1cf6fbbdeed2e024db3d9"
 dependencies = [
 "anyhow",
- "base64 0.21.2",
 "bytes",
 "cocoa",
 "dirs-next",
@ -3759,7 +3752,6 @@ dependencies = [
 "heck 0.4.1",
 "http",
 "ignore",
- "minisign-verify",
 "objc",
 "once_cell",
 "open",
@ -3784,14 +3776,12 @@ dependencies = [
 "tauri-utils",
 "tempfile",
 "thiserror",
- "time",
 "tokio",
 "url",
 "uuid",
 "webkit2gtk",
 "webview2-com",
 "windows 0.39.0",
- "zip",
 ]

 [[package]]
@ -3856,7 +3846,7 @@ dependencies = [
 [[package]]
 name = "tauri-plugin-fs-extra"
 version = "0.0.0"
-source = "git+https://github.com/tauri-apps/plugins-workspace?branch=v1#11048fd9975bf89e9bc2f192b735ac339f6bb43b"
+source = "git+https://github.com/tauri-apps/plugins-workspace?branch=v1#61e862597e7234ddca9d9c4b07700855841888f3"
 dependencies = [
 "log",
 "serde",
@ -4035,9 +4025,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

 [[package]]
 name = "tokio"
-version = "1.33.0"
+version = "1.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653"
+checksum = "d0c014766411e834f7af5b8f4cf46257aab4036ca95e9d2c144a10f59ad6f5b9"
 dependencies = [
 "backtrace",
 "bytes",
@ -4045,7 +4035,7 @@ dependencies = [
 "mio",
 "num_cpus",
 "pin-project-lite",
- "socket2 0.5.4",
+ "socket2 0.5.5",
 "windows-sys 0.48.0",
 ]

@ -5012,14 +5002,3 @@ checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
 dependencies = [
 "linked-hash-map",
 ]
-
-[[package]]
-name = "zip"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
-dependencies = [
- "byteorder",
- "crc32fast",
- "crossbeam-utils",
-]
--- a/src-tauri/Cargo.toml
+++ b/src-tauri/Cargo.toml
@ -22,7 +22,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 tauri = { version = "1.5.2", features = [ "os-all", "dialog-all", "fs-all", "http-request", "path-all", "shell-open", "shell-open-api", "updater", "devtools"] }
 tauri-plugin-fs-extra = { git = "https://github.com/tauri-apps/plugins-workspace", branch = "v1" }
-tokio = { version = "1.33.0", features = ["time"] }
+tokio = { version = "1.34.0", features = ["time"] }
 toml = "0.8.2"

 [features]
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@ -8,7 +8,7 @@
  },
  "package": {
    "productName": "kittycad-modeling",
-    "version": "0.11.1"
+    "version": "0.12.0"
  },
  "tauri": {
    "allowlist": {
@ -72,23 +72,13 @@
      },
      "resources": [],
      "shortDescription": "",
-      "targets": "all",
-      "windows": {
-        "certificateThumbprint": "F4C9A52FF7BC26EE5E054946F6B11DEEA94C748D",
-        "digestAlgorithm": "sha256",
-        "timestampUrl": "http://timestamp.digicert.com"
-      }
+      "targets": "all"
    },
    "security": {
      "csp": null
    },
    "updater": {
-      "active": true,
-      "endpoints": [
-        "https://dl.kittycad.io/releases/modeling-app/last_update.json"
-      ],
-      "dialog": true,
-      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEUzNzA4MjBEQjFBRTY4NzYKUldSMmFLNnhEWUp3NCtsT21Jd05wQktOaGVkOVp6MUFma0hNTDRDSnI2RkJJTEZOWG1ncFhqcU8K"
+      "active": false
    },
    "windows": [
      {
--- a/src-tauri/tauri.macos.conf.json
+++ b/src-tauri/tauri.macos.conf.json
@ -1,7 +1,6 @@
-
 {
  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
  "package": {
    "productName": "KittyCAD Modeling"
  }
-}
+}
--- a/src-tauri/tauri.release.conf.json
+++ b/src-tauri/tauri.release.conf.json
@ -0,0 +1,21 @@
+{
+  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
+  "tauri": {
+    "updater": {
+      "active": true,
+      "endpoints": [
+        "https://dl.kittycad.io/releases/modeling-app/last_update.json"
+      ],
+      "dialog": true,
+      "pubkey": "dW50cnVzdGVkIGNvbW1lbnQ6IG1pbmlzaWduIHB1YmxpYyBrZXk6IEUzNzA4MjBEQjFBRTY4NzYKUldSMmFLNnhEWUp3NCtsT21Jd05wQktOaGVkOVp6MUFma0hNTDRDSnI2RkJJTEZOWG1ncFhqcU8K"
+    },
+    "bundle": {
+      "identifier": "io.kittycad.modeling-app",
+      "windows": {
+        "certificateThumbprint": "F4C9A52FF7BC26EE5E054946F6B11DEEA94C748D",
+        "digestAlgorithm": "sha256",
+        "timestampUrl": "http://timestamp.digicert.com"
+      }
+    }
+  }
+}
--- a/src-tauri/tauri.windows.conf.json
+++ b/src-tauri/tauri.windows.conf.json
@ -1,7 +1,6 @@
-
 {
  "$schema": "../node_modules/@tauri-apps/cli/schema.json",
  "package": {
    "productName": "KittyCAD Modeling"
  }
-}
+}
--- a/src/App.tsx
+++ b/src/App.tsx
@ -1,4 +1,4 @@
-import { useEffect, useCallback, MouseEventHandler } from 'react'
+import { useCallback, MouseEventHandler } from 'react'
 import { DebugPanel } from './components/DebugPanel'
 import { v4 as uuidv4 } from 'uuid'
 import { PaneType, useStore } from './useStore'
@ -19,7 +19,6 @@ import {
 } from '@fortawesome/free-solid-svg-icons'
 import { useHotkeys } from 'react-hotkeys-hook'
 import { getNormalisedCoordinates } from './lib/utils'
-import { isTauri } from './lib/isTauri'
 import { useLoaderData } from 'react-router-dom'
 import { IndexLoaderData } from './Router'
 import { useGlobalStateContext } from 'hooks/useGlobalStateContext'
@ -31,11 +30,10 @@ import { TextEditor } from 'components/TextEditor'
 import { Themes, getSystemTheme } from 'lib/theme'
 import { useEngineConnectionSubscriptions } from 'hooks/useEngineConnectionSubscriptions'
 import { engineCommandManager } from './lang/std/engineConnection'
-import { kclManager } from 'lang/KclSinglton'
 import { useModelingContext } from 'hooks/useModelingContext'

 export function App() {
-  const { code: loadedCode, project, file } = useLoaderData() as IndexLoaderData
+  const { project, file } = useLoaderData() as IndexLoaderData

  useHotKeyListener()
  const {
@ -82,26 +80,6 @@ export function App() {
    ? 'opacity-40'
    : ''

-  // Use file code loaded from disk
-  // on mount, and overwrite any locally-stored code
-  useEffect(() => {
-    if (isTauri() && loadedCode !== null) {
-      if (kclManager.engineCommandManager.engineConnection?.isReady()) {
-        // If the engine is ready, promptly execute the loaded code
-        kclManager.setCodeAndExecute(loadedCode)
-      } else {
-        // Otherwise, just set the code and wait for the connection to complete
-        kclManager.setCode(loadedCode)
-      }
-    }
-    return () => {
-      // Clear code on unmount if in desktop app
-      if (isTauri()) {
-        kclManager.setCode('')
-      }
-    }
-  }, [loadedCode])
-
  useEngineConnectionSubscriptions()

  const debounceSocketSend = throttle<EngineCommand>((message) => {
@ -248,7 +226,7 @@ export function App() {
      <Stream className="absolute inset-0 z-0" />
      {showDebugPanel && (
        <DebugPanel
-          title="Debug"
+          title="Debug (AST Explorer)"
          className={
            'transition-opacity transition-duration-75 ' +
            paneOpacity +
--- a/src/Router.tsx
+++ b/src/Router.tsx
@ -42,7 +42,7 @@ import CommandBarProvider from 'components/CommandBar'
 import { TEST, VITE_KC_SENTRY_DSN } from './env'
 import * as Sentry from '@sentry/react'
 import ModelingMachineProvider from 'components/ModelingMachineProvider'
-import { KclContextProvider } from 'lang/KclSinglton'
+import { KclContextProvider, kclManager } from 'lang/KclSinglton'
 import FileMachineProvider from 'components/FileMachineProvider'
 import { sep } from '@tauri-apps/api/path'

@ -207,6 +207,7 @@ const router = createBrowserRouter(
            projectPath + sep + PROJECT_ENTRYPOINT
          )
          const children = await readDir(projectPath, { recursive: true })
+          kclManager.setCodeAndExecute(code, false)

          return {
            code,
--- a/src/components/AvailableVarsHelpers.tsx
+++ b/src/components/AvailableVarsHelpers.tsx
@ -1,5 +1,5 @@
 import { useEffect, useState, useRef } from 'react'
-import { parse, BinaryPart, Value, executor } from '../lang/wasm'
+import { parse, BinaryPart, Value } from '../lang/wasm'
 import {
  createIdentifier,
  createLiteral,
@ -10,6 +10,7 @@ import { findAllPreviousVariables, PrevVariable } from '../lang/queryAst'
 import { engineCommandManager } from '../lang/std/engineConnection'
 import { kclManager, useKclContext } from 'lang/KclSinglton'
 import { useModelingContext } from 'hooks/useModelingContext'
+import { executeAst } from 'useStore'

 export const AvailableVars = ({
  onVarClick,
@ -130,27 +131,29 @@ export function useCalc({
    if (!programMemory || !selectionRange) return
    const varInfo = findAllPreviousVariables(
      kclManager.ast,
-      programMemory,
+      kclManager.programMemory,
      selectionRange
    )
    setAvailableVarInfo(varInfo)
-  }, [kclManager.ast, programMemory, selectionRange])
+  }, [kclManager.ast, kclManager.programMemory, selectionRange])

  useEffect(() => {
    try {
-      const code = `const __result__ = ${value}\nshow(__result__)`
+      const code = `const __result__ = ${value}`
      const ast = parse(code)
      const _programMem: any = { root: {}, return: null }
      availableVarInfo.variables.forEach(({ key, value }) => {
        _programMem.root[key] = { type: 'userVal', value, __meta: [] }
      })
-
-      executor(
+      executeAst({
        ast,
-        _programMem,
        engineCommandManager,
-        kclManager.defaultPlanes
-      ).then((programMemory) => {
+        defaultPlanes: kclManager.defaultPlanes,
+        useFakeExecutor: true,
+        programMemoryOverride: JSON.parse(
+          JSON.stringify(kclManager.programMemory)
+        ),
+      }).then(({ programMemory }) => {
        const resultDeclaration = ast.body.find(
          (a) =>
            a.type === 'VariableDeclaration' &&
@ -167,7 +170,7 @@ export function useCalc({
      setCalcResult('NAN')
      setValueNode(null)
    }
-  }, [value])
+  }, [value, availableVarInfo])

  return {
    valueNode,
@ -212,7 +215,10 @@ export const CreateNewVariable = ({
 }) => {
  return (
    <>
-      <label htmlFor="create-new-variable" className="block mt-3 font-mono">
+      <label
+        htmlFor="create-new-variable"
+        className="block mt-3 font-mono text-gray-900"
+      >
        Create new variable
      </label>
      <div className="mt-1 flex gap-2 items-center">
@ -223,6 +229,7 @@ export const CreateNewVariable = ({
            onChange={(e) => {
              setShouldCreateVariable(e.target.checked)
            }}
+            className="bg-white text-gray-900"
          />
        )}
        <input
--- a/src/components/DebugPanel.tsx
+++ b/src/components/DebugPanel.tsx
@ -1,29 +1,7 @@
 import { CollapsiblePanel, CollapsiblePanelProps } from './CollapsiblePanel'
-import { v4 as uuidv4 } from 'uuid'
-import { EngineCommand } from '../lang/std/engineConnection'
-import { useState } from 'react'
-import { ActionButton } from '../components/ActionButton'
-import { faCheck } from '@fortawesome/free-solid-svg-icons'
-import { isReducedMotion } from 'lang/util'
 import { AstExplorer } from './AstExplorer'
-import { engineCommandManager } from '../lang/std/engineConnection'
-
-type SketchModeCmd = Extract<
-  Extract<EngineCommand, { type: 'modeling_cmd_req' }>['cmd'],
-  { type: 'default_camera_enable_sketch_mode' }
->

 export const DebugPanel = ({ className, ...props }: CollapsiblePanelProps) => {
-  const [sketchModeCmd, setSketchModeCmd] = useState<SketchModeCmd>({
-    type: 'default_camera_enable_sketch_mode',
-    origin: { x: 0, y: 0, z: 0 },
-    x_axis: { x: 1, y: 0, z: 0 },
-    y_axis: { x: 0, y: 1, z: 0 },
-    distance_to_plane: 100,
-    ortho: true,
-    animated: !isReducedMotion(),
-  })
-  if (!sketchModeCmd) return null
  return (
    <CollapsiblePanel
      {...props}
@ -34,67 +12,6 @@ export const DebugPanel = ({ className, ...props }: CollapsiblePanelProps) => {
      style={{ maxHeight: 'calc(100% - 3rem - 1.25rem - 1.25rem)' }}
    >
      <section className="p-4 flex flex-col gap-4">
-        <Xyz
-          onChange={setSketchModeCmd}
-          pointKey="origin"
-          data={sketchModeCmd}
-        />
-        <Xyz
-          onChange={setSketchModeCmd}
-          pointKey="x_axis"
-          data={sketchModeCmd}
-        />
-        <Xyz
-          onChange={setSketchModeCmd}
-          pointKey="y_axis"
-          data={sketchModeCmd}
-        />
-        <div className="flex">
-          <div className="pr-4">distance_to_plane</div>
-          <input
-            className="w-16 dark:bg-chalkboard-90"
-            type="number"
-            value={sketchModeCmd.distance_to_plane}
-            onChange={({ target }) => {
-              setSketchModeCmd({
-                ...sketchModeCmd,
-                distance_to_plane: Number(target.value),
-              })
-            }}
-          />
-          <div className="pr-4">ortho</div>
-          <input
-            className="w-16"
-            type="checkbox"
-            checked={sketchModeCmd.ortho}
-            onChange={(a) =>
-              setSketchModeCmd({
-                ...sketchModeCmd,
-                ortho: a.target.checked,
-              })
-            }
-          />
-        </div>
-        <ActionButton
-          Element="button"
-          onClick={() => {
-            engineCommandManager.sendSceneCommand({
-              type: 'modeling_cmd_req',
-              cmd: sketchModeCmd,
-              cmd_id: uuidv4(),
-            })
-          }}
-          className="hover:border-succeed-50"
-          icon={{
-            icon: faCheck,
-            bgClassName:
-              'bg-succeed-80 group-hover:bg-succeed-70 hover:bg-succeed-70',
-            iconClassName:
-              'text-succeed-20 group-hover:text-succeed-10 hover:text-succeed-10',
-          }}
-        >
-          Send sketch mode command
-        </ActionButton>
        <div style={{ height: '400px' }} className="overflow-y-auto">
          <AstExplorer />
        </div>
@ -102,41 +19,3 @@ export const DebugPanel = ({ className, ...props }: CollapsiblePanelProps) => {
    </CollapsiblePanel>
  )
 }
-
-const Xyz = ({
-  pointKey,
-  data,
-  onChange,
-}: {
-  pointKey: 'origin' | 'y_axis' | 'x_axis'
-  data: SketchModeCmd
-  onChange: (a: SketchModeCmd) => void
-}) => {
-  if (!data) return null
-  return (
-    <div className="flex">
-      <div className="pr-4">{pointKey}</div>
-      {Object.entries(data[pointKey]).map(([axis, val]) => {
-        return (
-          <div key={axis} className="flex">
-            <div className="w-4">{axis}</div>
-            <input
-              className="w-16 dark:bg-chalkboard-90"
-              type="number"
-              value={val}
-              onChange={({ target }) => {
-                onChange({
-                  ...data,
-                  [pointKey]: {
-                    ...data[pointKey],
-                    [axis]: Number(target.value),
-                  },
-                })
-              }}
-            />
-          </div>
-        )
-      })}
-    </div>
-  )
-}
--- a/src/components/FileTree.tsx
+++ b/src/components/FileTree.tsx
@ -9,7 +9,6 @@ import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'
 import { faChevronRight, faTrashAlt } from '@fortawesome/free-solid-svg-icons'
 import { useFileContext } from 'hooks/useFileContext'
 import { useHotkeys } from 'react-hotkeys-hook'
-import { kclManager } from 'lang/KclSinglton'
 import styles from './FileTree.module.css'
 import { sortProject } from 'lib/tauriFS'

@ -163,7 +162,6 @@ const FileTreeItem = ({

  function openFile() {
    if (fileOrDir.children !== undefined) return // Don't open directories
-    kclManager.setCode('')
    navigate(`${paths.FILE}/${encodeURIComponent(fileOrDir.path)}`)
    closePanel()
  }
--- a/src/components/ModelingMachineProvider.tsx
+++ b/src/components/ModelingMachineProvider.tsx
@ -147,7 +147,7 @@ export const ModelingMachineProvider = ({
            engineCommandManager.artifactMap[sketchEnginePathId] = {
              type: 'result',
              range: [startProfileAtCallExp.start, startProfileAtCallExp.end],
-              commandType: 'extend_path',
+              commandType: 'start_path',
              data: null,
              raw: {} as any,
            }
--- a/src/components/SetAngleLengthModal.tsx
+++ b/src/components/SetAngleLengthModal.tsx
@ -108,7 +108,7 @@ export const SetAngleLengthModal = ({
                </label>
                <div className="mt-1 flex">
                  <button
-                    className="border border-gray-300 px-2"
+                    className="border border-gray-300 px-2 text-gray-900"
                    onClick={() => setSign(-sign)}
                  >
                    {sign > 0 ? '+' : '-'}
@ -118,7 +118,7 @@ export const SetAngleLengthModal = ({
                    type="text"
                    name="val"
                    id="val"
-                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm border-gray-300 rounded-md font-mono pl-1"
+                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm border-gray-300 rounded-md font-mono pl-1 text-gray-900"
                    value={value}
                    onChange={(e) => {
                      setValue(e.target.value)
--- a/src/components/SetHorVertDistanceModal.tsx
+++ b/src/components/SetHorVertDistanceModal.tsx
@ -87,7 +87,7 @@ export const GetInfoModal = ({
              leaveFrom="opacity-100 scale-100"
              leaveTo="opacity-0 scale-95"
            >
-              <Dialog.Panel className="w-full max-w-md transform overflow-hidden rounded-2xl bg-white p-6 text-left align-middle shadow-xl transition-all">
+              <Dialog.Panel className="w-full max-w-md transform overflow-hidden rounded-2xl bg-white/90 p-6 text-left align-middle shadow-xl transition-all">
                <Dialog.Title
                  as="h3"
                  className="text-lg font-medium leading-6 text-gray-900"
@ -109,7 +109,7 @@ export const GetInfoModal = ({
                </label>
                <div className="mt-1 flex">
                  <button
-                    className="border border-gray-300 px-2 mr-1"
+                    className="border border-gray-400 px-2 mr-1 text-gray-900"
                    onClick={() => setSign(-sign)}
                  >
                    {sign > 0 ? '+' : '-'}
@ -119,7 +119,7 @@ export const GetInfoModal = ({
                    name="val"
                    id="val"
                    ref={inputRef}
-                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm border-gray-300 rounded-md font-mono"
+                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm text-gray-900 border-gray-300 rounded-md font-mono"
                    value={value}
                    onChange={(e) => {
                      setValue(e.target.value)
@ -139,7 +139,7 @@ export const GetInfoModal = ({
                    name="segName"
                    id="segName"
                    disabled={!isSegNameEditable}
-                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm border-gray-300 rounded-md font-mono"
+                    className="shadow-sm focus:ring-blue-500 focus:border-blue-500 block w-full sm:text-sm text-gray-900 border-gray-300 rounded-md font-mono"
                    value={segName}
                    onChange={(e) => {
                      setSegName(e.target.value)
--- a/src/components/Stream.tsx
+++ b/src/components/Stream.tsx
@ -14,7 +14,7 @@ import { useGlobalStateContext } from 'hooks/useGlobalStateContext'
 import { CameraDragInteractionType_type } from '@kittycad/lib/dist/types/src/models'
 import { Models } from '@kittycad/lib'
 import { getNodeFromPath } from 'lang/queryAst'
-import { VariableDeclarator, recast, parse, CallExpression } from 'lang/wasm'
+import { VariableDeclarator, recast, CallExpression } from 'lang/wasm'
 import { engineCommandManager } from '../lang/std/engineConnection'
 import { useModelingContext } from 'hooks/useModelingContext'
 import { kclManager, useKclContext } from 'lang/KclSinglton'
@ -342,7 +342,8 @@ export const Stream = ({ className = '' }) => {

          // update artifact map ranges now that we have updated the ast.
          code = recast(modded.modifiedAst)
-          const astWithCurrentRanges = parse(code)
+          const astWithCurrentRanges = kclManager.safeParse(code)
+          if (!astWithCurrentRanges) return
          const updateNode = getNodeFromPath<CallExpression>(
            astWithCurrentRanges,
            modded.pathToNode
--- a/src/components/TextEditor.tsx
+++ b/src/components/TextEditor.tsx
@ -17,15 +17,7 @@ import { useStore } from 'useStore'
 import { processCodeMirrorRanges } from 'lib/selections'
 import { LanguageServerClient } from 'editor/lsp'
 import kclLanguage from 'editor/lsp/language'
-import { isTauri } from 'lib/isTauri'
-import { useParams } from 'react-router-dom'
-import { writeTextFile } from '@tauri-apps/api/fs'
-import { toast } from 'react-hot-toast'
-import {
-  EditorView,
-  addLineHighlight,
-  lineHighlightField,
-} from 'editor/highlightextension'
+import { EditorView, lineHighlightField } from 'editor/highlightextension'
 import { roundOff } from 'lib/utils'
 import { kclErrToDiagnostic } from 'lang/errors'
 import { CSSRuleObject } from 'tailwindcss/types/config'
@ -50,7 +42,6 @@ export const TextEditor = ({
 }: {
  theme: Themes.Light | Themes.Dark
 }) => {
-  const pathParams = useParams()
  const { editorView, isLSPServerReady, setEditorView, setIsLSPServerReady } =
    useStore((s) => ({
      editorView: s.editorView,
@ -113,18 +104,6 @@ export const TextEditor = ({
  // const onChange = React.useCallback((value: string, viewUpdate: ViewUpdate) => {
  const onChange = (newCode: string) => {
    kclManager.setCodeAndExecute(newCode)
-    if (isTauri() && pathParams.id) {
-      // Save the file to disk
-      // Note that PROJECT_ENTRYPOINT is hardcoded until we support multiple files
-      writeTextFile(pathParams.id, newCode).catch((err) => {
-        // TODO: add Sentry per GH issue #254 (https://github.com/KittyCAD/modeling-app/issues/254)
-        console.error('error saving file', err)
-        toast.error('Error saving file, please check file permissions')
-      })
-    }
-    if (editorView) {
-      editorView?.dispatch({ effects: addLineHighlight.of([0, 0]) })
-    }
  } //, []);
  const onUpdate = (viewUpdate: ViewUpdate) => {
    if (!editorView) {
--- a/src/hooks/useEngineConnectionSubscriptions.ts
+++ b/src/hooks/useEngineConnectionSubscriptions.ts
@ -35,7 +35,7 @@ export function useEngineConnectionSubscriptions() {
        const event = await getEventForSelectWithPoint(engineEvent, {
          sketchEnginePathId: context.sketchEnginePathId,
        })
-        send(event)
+        event && send(event)
      },
    })
    return () => {
--- a/src/hooks/useSetupEngineManager.ts
+++ b/src/hooks/useSetupEngineManager.ts
@ -26,10 +26,6 @@ export function useSetupEngineManager(

  const hasSetNonZeroDimensions = useRef<boolean>(false)

-  useEffect(() => {
-    kclManager.executeCode()
-  }, [])
-
  useLayoutEffect(() => {
    // Load the engine command manager once with the initial width and height,
    // then we do not want to reload it.
@ -86,9 +82,14 @@ export function useSetupEngineManager(
 }

 function getDimensions(streamWidth?: number, streamHeight?: number) {
+  const maxResolution = 2000
  const width = streamWidth ? streamWidth : 0
-  const quadWidth = Math.round(width / 4) * 4
  const height = streamHeight ? streamHeight : 0
-  const quadHeight = Math.round(height / 4) * 4
+  const ratio = Math.min(
+    Math.min(maxResolution / width, maxResolution / height),
+    1.0
+  )
+  const quadWidth = Math.round((width * ratio) / 4) * 4
+  const quadHeight = Math.round((height * ratio) / 4) * 4
  return { width: quadWidth, height: quadHeight }
 }
--- a/src/lang/KclSinglton.tsx
+++ b/src/lang/KclSinglton.tsx
@ -18,7 +18,11 @@ import { bracket } from 'lib/exampleKcl'
 import { createContext, useContext, useEffect, useState } from 'react'
 import { getNodeFromPath } from './queryAst'
 import { IndexLoaderData } from 'Router'
-import { useLoaderData } from 'react-router-dom'
+import { Params, useLoaderData } from 'react-router-dom'
+import { isTauri } from 'lib/isTauri'
+import { writeTextFile } from '@tauri-apps/api/fs'
+import { toast } from 'react-hot-toast'
+import { useParams } from 'react-router-dom'

 const PERSIST_CODE_TOKEN = 'persistCode'

@ -41,10 +45,20 @@ class KclManager {
  private _kclErrors: KCLError[] = []
  private _isExecuting = false
  private _wasmInitFailed = true
+  private _params: Params<string> = {}

  engineCommandManager: EngineCommandManager
  private _defferer = deferExecution((code: string) => {
-    const ast = parse(code)
+    const ast = this.safeParse(code)
+    if (!ast) return
+    try {
+      const fmtAndStringify = (ast: Program) =>
+        JSON.stringify(parse(recast(ast)))
+      const isAstTheSame = fmtAndStringify(ast) === fmtAndStringify(this._ast)
+      if (isAstTheSame) return
+    } catch (e) {
+      console.error(e)
+    }
    this.executeAst(ast)
  }, 600)

@ -71,6 +85,21 @@ class KclManager {
  set code(code) {
    this._code = code
    this._codeCallBack(code)
+    if (isTauri()) {
+      setTimeout(() => {
+        // Wait one event loop to give a chance for params to be set
+        // Save the file to disk
+        // Note that PROJECT_ENTRYPOINT is hardcoded until we support multiple files
+        this._params.id &&
+          writeTextFile(this._params.id, code).catch((err) => {
+            // TODO: add Sentry per GH issue #254 (https://github.com/KittyCAD/modeling-app/issues/254)
+            console.error('error saving file', err)
+            toast.error('Error saving file, please check file permissions')
+          })
+      })
+    } else {
+      localStorage.setItem(PERSIST_CODE_TOKEN, code)
+    }
  }

  get programMemory() {
@ -117,8 +146,17 @@ class KclManager {
    this._wasmInitFailedCallback(wasmInitFailed)
  }

+  setParams(params: Params<string>) {
+    this._params = params
+  }
+
  constructor(engineCommandManager: EngineCommandManager) {
    this.engineCommandManager = engineCommandManager
+
+    if (isTauri()) {
+      this.code = ''
+      return
+    }
    const storedCode = localStorage.getItem(PERSIST_CODE_TOKEN)
    // TODO #819 remove zustand persistence logic in a few months
    // short term migration, shouldn't make a difference for tauri app users
@ -130,6 +168,7 @@ class KclManager {
      zustandStore.state.code = ''
      localStorage.setItem('store', JSON.stringify(zustandStore))
    } else if (storedCode === null) {
+      console.log('stored brack thing')
      this.code = bracket
    } else {
      this.code = storedCode
@ -164,6 +203,21 @@ class KclManager {
    this._executeCallback = callback
  }

+  safeParse(code: string): Program | null {
+    try {
+      const ast = parse(code)
+      this.kclErrors = []
+      return ast
+    } catch (e) {
+      console.error('error parsing code', e)
+      if (e instanceof KCLError) {
+        this.kclErrors = [e]
+        if (e.msg === 'file is empty') engineCommandManager.endSession()
+      }
+      return null
+    }
+  }
+
  async ensureWasmInit() {
    try {
      await initPromise
@ -184,20 +238,20 @@ class KclManager {
      defaultPlanes: this.defaultPlanes,
    })
    this.isExecuting = false
-    this._logs = logs
-    this._kclErrors = errors
-    this._programMemory = programMemory
-    this._ast = { ...ast }
+    this.logs = logs
+    this.kclErrors = errors
+    this.programMemory = programMemory
+    this.ast = { ...ast }
    if (updateCode) {
-      this._code = recast(ast)
-      this._codeCallBack(this._code)
+      this.code = recast(ast)
    }
    this._executeCallback()
  }
  async executeAstMock(ast: Program = this._ast, updateCode = false) {
    await this.ensureWasmInit()
    const newCode = recast(ast)
-    const newAst = parse(newCode)
+    const newAst = this.safeParse(newCode)
+    if (!newAst) return
    await this?.engineCommandManager?.waitForReady
    if (updateCode) {
      this.setCode(recast(ast))
@ -233,13 +287,17 @@ class KclManager {
    this.ast = ast
    if (code) this.code = code
  }
-  setCode(code: string) {
+  setCode(code: string, shouldWriteFile = true) {
+    if (shouldWriteFile) {
+      // use the normal code setter
+      this.code = code
+      return
+    }
    this._code = code
    this._codeCallBack(code)
-    localStorage.setItem(PERSIST_CODE_TOKEN, code)
  }
-  setCodeAndExecute(code: string) {
-    this.setCode(code)
+  setCodeAndExecute(code: string, shouldWriteFile = true) {
+    this.setCode(code, shouldWriteFile)
    if (code.trim()) {
      this._defferer(code)
      return
@ -260,7 +318,9 @@ class KclManager {
    this.engineCommandManager.endSession()
  }
  format() {
-    this.code = recast(parse(kclManager.code))
+    const ast = this.safeParse(this.code)
+    if (!ast) return
+    this.code = recast(ast)
  }
  // There's overlapping responsibility between updateAst and executeAst.
  // updateAst was added as it was used a lot before xState migration so makes the port easier.
@ -270,15 +330,13 @@ class KclManager {
    execute: boolean,
    optionalParams?: {
      focusPath?: PathToNode
-      callBack?: (ast: Program) => void
    }
  ): Promise<Selections | null> {
    const newCode = recast(ast)
-    const astWithUpdatedSource = parse(newCode)
-    optionalParams?.callBack?.(astWithUpdatedSource)
+    const astWithUpdatedSource = this.safeParse(newCode)
+    if (!astWithUpdatedSource) return null
    let returnVal: Selections | null = null

-    this.code = newCode
    if (optionalParams?.focusPath) {
      const { node } = getNodeFromPath<any>(
        astWithUpdatedSource,
@ -299,12 +357,12 @@ class KclManager {

    if (execute) {
      // Call execute on the set ast.
-      await this.executeAst(astWithUpdatedSource)
+      await this.executeAst(astWithUpdatedSource, true)
    } else {
      // When we don't re-execute, we still want to update the program
      // memory with the new ast. So we will hit the mock executor
      // instead.
-      await this.executeAstMock(astWithUpdatedSource)
+      await this.executeAstMock(astWithUpdatedSource, true)
    }
    return returnVal
  }
@ -369,6 +427,11 @@ export function KclContextProvider({
      setWasmInitFailed,
    })
  }, [])
+
+  const params = useParams()
+  useEffect(() => {
+    kclManager.setParams(params)
+  }, [params])
  return (
    <KclContext.Provider
      value={{
--- a/src/lang/abstractSyntaxTree.test.ts
+++ b/src/lang/abstractSyntaxTree.test.ts
@ -331,9 +331,6 @@ const myVar = funcN(1, 2)`
                  raw: '2',
                },
              ],
-              function: {
-                type: 'InMemory',
-              },
              optional: false,
            },
          },
@ -403,7 +400,6 @@ describe('testing pipe operator special', () => {
                      ],
                    },
                  ],
-                  function: expect.any(Object),
                  optional: false,
                },
                {
@ -440,7 +436,6 @@ describe('testing pipe operator special', () => {
                    },
                    { type: 'PipeSubstitution', start: 59, end: 60 },
                  ],
-                  function: expect.any(Object),
                  optional: false,
                },
                {
@ -513,7 +508,6 @@ describe('testing pipe operator special', () => {
                    },
                    { type: 'PipeSubstitution', start: 105, end: 106 },
                  ],
-                  function: expect.any(Object),
                  optional: false,
                },
                {
@ -550,7 +544,6 @@ describe('testing pipe operator special', () => {
                    },
                    { type: 'PipeSubstitution', start: 128, end: 129 },
                  ],
-                  function: expect.any(Object),
                  optional: false,
                },
                {
@ -573,9 +566,6 @@ describe('testing pipe operator special', () => {
                    },
                    { type: 'PipeSubstitution', start: 143, end: 144 },
                  ],
-                  function: {
-                    type: 'InMemory',
-                  },
                  optional: false,
                },
              ],
@ -655,9 +645,6 @@ describe('testing pipe operator special', () => {
                      end: 35,
                    },
                  ],
-                  function: {
-                    type: 'InMemory',
-                  },
                  optional: false,
                },
              ],
@ -1567,7 +1554,6 @@ describe('test UnaryExpression', () => {
          { type: 'Literal', start: 19, end: 20, value: 4, raw: '4' },
          { type: 'Literal', start: 22, end: 25, value: 100, raw: '100' },
        ],
-        function: expect.any(Object),
        optional: false,
      },
    })
@ -1601,12 +1587,10 @@ describe('testing nested call expressions', () => {
              { type: 'Literal', start: 34, end: 35, value: 5, raw: '5' },
              { type: 'Literal', start: 37, end: 38, value: 3, raw: '3' },
            ],
-            function: expect.any(Object),
            optional: false,
          },
        },
      ],
-      function: expect.any(Object),
      optional: false,
    })
  })
@ -1638,7 +1622,6 @@ describe('should recognise callExpresions in binaryExpressions', () => {
            },
            { type: 'PipeSubstitution', start: 25, end: 26 },
          ],
-          function: expect.any(Object),
          optional: false,
        },
        right: { type: 'Literal', value: 1, raw: '1', start: 30, end: 31 },
--- a/src/lang/errors.ts
+++ b/src/lang/errors.ts
@ -25,6 +25,13 @@ export class KCLLexicalError extends KCLError {
  }
 }

+export class KCLInternalError extends KCLError {
+  constructor(msg: string, sourceRanges: [number, number][]) {
+    super('internal', msg, sourceRanges)
+    Object.setPrototypeOf(this, KCLSyntaxError.prototype)
+  }
+}
+
 export class KCLSyntaxError extends KCLError {
  constructor(msg: string, sourceRanges: [number, number][]) {
    super('syntax', msg, sourceRanges)
--- a/src/lang/modifyAst.ts
+++ b/src/lang/modifyAst.ts
@ -480,21 +480,6 @@ export function createCallExpressionStdLib(
      end: 0,
      name,
    },
-    function: {
-      type: 'StdLib',
-      func: {
-        // We only need the name here to map it back when it serializes
-        // to rust, don't worry about the rest.
-        name,
-        summary: '',
-        description: '',
-        tags: [],
-        returnValue: { type: '', required: false, name: '', schema: {} },
-        args: [],
-        unpublished: false,
-        deprecated: false,
-      },
-    },
    optional: false,
    arguments: args,
  }
@ -514,9 +499,6 @@ export function createCallExpression(
      end: 0,
      name,
    },
-    function: {
-      type: 'InMemory',
-    },
    optional: false,
    arguments: args,
  }
--- a/src/lang/std/engineConnection.ts
+++ b/src/lang/std/engineConnection.ts
@ -216,6 +216,26 @@ export class EngineConnection {
      }
    })

+    this.pc.addEventListener('icecandidateerror', (_event) => {
+      const event = _event as RTCPeerConnectionIceErrorEvent
+      console.error(
+        `ICE candidate returned an error: ${event.errorCode}: ${event.errorText} for ${event.url}`
+      )
+    })
+
+    this.pc.addEventListener('connectionstatechange', (event) => {
+      if (this.pc?.iceConnectionState === 'connected') {
+        if (this.shouldTrace()) {
+          iceSpan.resolve?.()
+        }
+      } else if (this.pc?.iceConnectionState === 'failed') {
+        // failed is a terminal state; let's explicitly kill the
+        // connection to the server at this point.
+        console.log('failed to negotiate ice connection; restarting')
+        this.close()
+      }
+    })
+
    this.websocket.addEventListener('open', (event) => {
      if (this.shouldTrace()) {
        websocketSpan.resolve?.()
@ -351,19 +371,6 @@ export class EngineConnection {
        // until the end of this function is setup of our end of the
        // PeerConnection and waiting for events to fire our callbacks.

-        this.pc.addEventListener('connectionstatechange', (event) => {
-          if (this.pc?.iceConnectionState === 'connected') {
-            if (this.shouldTrace()) {
-              iceSpan.resolve?.()
-            }
-          } else if (this.pc?.iceConnectionState === 'failed') {
-            // failed is a terminal state; let's explicitly kill the
-            // connection to the server at this point.
-            console.log('failed to negotiate ice connection; restarting')
-            this.close()
-          }
-        })
-
        this.pc.addEventListener('icecandidate', (event) => {
          if (!this.pc || !this.websocket) return
          if (event.candidate !== null) {
@ -633,7 +640,10 @@ export class EngineCommandManager {

    // If we already have an engine connection, just need to resize the stream.
    if (this.engineConnection) {
-      this.handleResize({ streamWidth: width, streamHeight: height })
+      this.handleResize({
+        streamWidth: width,
+        streamHeight: height,
+      })
      return
    }

@ -889,6 +899,7 @@ export class EngineCommandManager {
    // TODO: instead of sending a single command with `object_ids: Object.keys(this.artifactMap)`
    // we need to loop over them each individually because if the engine doesn't recognise a single
    // id the whole command fails.
+    const artifactsToDelete: any = {}
    Object.entries(this.artifactMap).forEach(([id, artifact]) => {
      const artifactTypesToDelete: ArtifactMap[string]['commandType'][] = [
        // 'start_path' creates a new scene object for the path, which is why it needs to be deleted,
@ -898,7 +909,9 @@ export class EngineCommandManager {
        'start_path',
      ]
      if (!artifactTypesToDelete.includes(artifact.commandType)) return
-
+      artifactsToDelete[id] = artifact
+    })
+    Object.keys(artifactsToDelete).forEach((id) => {
      const deletCmd: EngineCommand = {
        type: 'modeling_cmd_req',
        cmd_id: uuidv4(),
--- a/src/lang/std/sketch.ts
+++ b/src/lang/std/sketch.ts
@ -946,7 +946,7 @@ export function compareVec2Epsilon(
 ) {
  const compareEpsilon = 0.015625 // or 2^-6
  const xDifference = Math.abs(vec1[0] - vec2[0])
-  const yDifference = Math.abs(vec1[0] - vec2[0])
+  const yDifference = Math.abs(vec1[1] - vec2[1])
  return xDifference < compareEpsilon && yDifference < compareEpsilon
 }

--- a/src/lib/exampleKcl.ts
+++ b/src/lib/exampleKcl.ts
@ -26,5 +26,4 @@ const bracket = startSketchOn('XY')
  |> close(%)
  |> extrude(width, %)

-show(bracket)
 `
--- a/src/lib/selections.ts
+++ b/src/lib/selections.ts
@ -102,8 +102,8 @@ export async function getEventForSelectWithPoint(
    Models['OkModelingCmdResponse_type'],
    { type: 'select_with_point' }
  >,
-  { sketchEnginePathId }: { sketchEnginePathId: string }
-): Promise<ModelingMachineEvent> {
+  { sketchEnginePathId }: { sketchEnginePathId?: string }
+): Promise<ModelingMachineEvent | null> {
  if (!data?.entity_id) {
    return {
      type: 'Set selection',
@ -120,6 +120,7 @@ export async function getEventForSelectWithPoint(
      },
    }
  }
+  if (!sketchEnginePathId) return null
  // selected a vertex
  const res = await engineCommandManager.sendSceneCommand({
    type: 'modeling_cmd_req',
--- a/src/lib/tauriFS.ts
+++ b/src/lib/tauriFS.ts
@ -9,7 +9,6 @@ import { documentDir, homeDir, sep } from '@tauri-apps/api/path'
 import { isTauri } from './isTauri'
 import { ProjectWithEntryPointMetadata } from '../Router'
 import { metadata } from 'tauri-plugin-fs-extra-api'
-import { bracket } from './exampleKcl'

 const PROJECT_FOLDER = 'kittycad-modeling-projects'
 export const FILE_EXT = '.kcl'
@ -211,7 +210,8 @@ export function sortProject(project: FileEntry[]): FileEntry[] {
 // Creates a new file in the default directory with the default project name
 // Returns the path to the new file
 export async function createNewProject(
-  path: string
+  path: string,
+  initCode = ''
 ): Promise<ProjectWithEntryPointMetadata> {
  if (!isTauri) {
    throw new Error('createNewProject() can only be called from a Tauri app')
@ -225,10 +225,12 @@ export async function createNewProject(
    })
  }

-  await writeTextFile(path + sep + PROJECT_ENTRYPOINT, bracket).catch((err) => {
-    console.error('Error creating new file:', err)
-    throw err
-  })
+  await writeTextFile(path + sep + PROJECT_ENTRYPOINT, initCode).catch(
+    (err) => {
+      console.error('Error creating new file:', err)
+      throw err
+    }
+  )

  const m = await metadata(path)

--- a/src/routes/Onboarding/Introduction.tsx
+++ b/src/routes/Onboarding/Introduction.tsx
@ -43,7 +43,10 @@ function OnboardingWithNewFile() {
      ONBOARDING_PROJECT_NAME,
      nextIndex
    )
-    const newFile = await createNewProject(defaultDirectory + sep + name)
+    const newFile = await createNewProject(
+      defaultDirectory + sep + name,
+      bracket
+    )
    navigate(
      `${paths.FILE}/${encodeURIComponent(
        newFile.path + sep + PROJECT_ENTRYPOINT
@ -79,7 +82,7 @@ function OnboardingWithNewFile() {
              <ActionButton
                Element="button"
                onClick={() => {
-                  kclManager.setCode(bracket)
+                  kclManager.setCodeAndExecute(bracket)
                  next()
                }}
                icon={{ icon: faArrowRight }}
@ -118,7 +121,7 @@ function OnboardingWithNewFile() {
                Element="button"
                onClick={() => {
                  createAndOpenNewProject()
-                  kclManager.setCode(bracket)
+                  kclManager.setCode(bracket, false)
                  dismiss()
                }}
                icon={{ icon: faArrowRight }}
--- a/src/routes/Settings.tsx
+++ b/src/routes/Settings.tsx
@ -32,6 +32,7 @@ import {
 } from 'lib/tauriFS'
 import { ONBOARDING_PROJECT_NAME } from './Onboarding'
 import { sep } from '@tauri-apps/api/path'
+import { bracket } from 'lib/exampleKcl'

 export const Settings = () => {
  const loaderData =
@ -96,7 +97,10 @@ export const Settings = () => {
      ONBOARDING_PROJECT_NAME,
      nextIndex
    )
-    const newFile = await createNewProject(defaultDirectory + sep + name)
+    const newFile = await createNewProject(
+      defaultDirectory + sep + name,
+      bracket
+    )
    navigate(`${paths.FILE}/${encodeURIComponent(newFile.path)}`)
  }

--- a/src/useStore.ts
+++ b/src/useStore.ts
@ -253,11 +253,13 @@ export async function executeAst({
  engineCommandManager,
  defaultPlanes,
  useFakeExecutor = false,
+  programMemoryOverride,
 }: {
  ast: Program
  engineCommandManager: EngineCommandManager
  defaultPlanes: DefaultPlanes
  useFakeExecutor?: boolean
+  programMemoryOverride?: ProgramMemory
 }): Promise<{
  logs: string[]
  errors: KCLError[]
@ -269,10 +271,13 @@ export async function executeAst({
      engineCommandManager.startNewSession()
    }
    const programMemory = await (useFakeExecutor
-      ? enginelessExecutor(ast, {
-          root: defaultProgramMemory,
-          return: null,
-        })
+      ? enginelessExecutor(
+          ast,
+          programMemoryOverride || {
+            root: defaultProgramMemory,
+            return: null,
+          }
+        )
      : _executor(
          ast,
          {
--- a/src/wasm-lib/.config/nextest.toml
+++ b/src/wasm-lib/.config/nextest.toml
@ -6,10 +6,10 @@
 serial-integration = { max-threads = 4 }

 [profile.default]
-slow-timeout = { period = "60s", terminate-after = 1 }
+slow-timeout = { period = "10s", terminate-after = 1 }

 [profile.ci]
-slow-timeout = { period = "120s", terminate-after = 10 }
+slow-timeout = { period = "30s", terminate-after = 5 }

 [[profile.default.overrides]]
 filter = "test(serial_test_)"
@ -20,3 +20,7 @@ threads-required = 4
 filter = "test(serial_test_)"
 test-group = "serial-integration"
 threads-required = 4
+
+[[profile.default.overrides]]
+filter = "test(parser::parser_impl::snapshot_tests)"
+slow-timeout = { period = "1s", terminate-after = 5 }
--- a/src/wasm-lib/Cargo.lock
+++ b/src/wasm-lib/Cargo.lock
@ -157,7 +157,7 @@ checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -168,7 +168,7 @@ checksum = "a66537f1bb974b254c98ed142ff995236e81b9d0fe4db0575f46612cb15eb0f9"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -447,9 +447,9 @@ dependencies = [

 [[package]]
 name = "clap"
-version = "4.4.7"
+version = "4.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac495e00dcec98c83465d5ad66c5c4fabd652fd6686e7c6269b117e729a6f17b"
+checksum = "2275f18819641850fa26c89acc84d465c1bf91ce57bc2748b28c420473352f64"
 dependencies = [
 "clap_builder",
 "clap_derive",
@ -457,9 +457,9 @@ dependencies = [

 [[package]]
 name = "clap_builder"
-version = "4.4.7"
+version = "4.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77ed9a32a62e6ca27175d00d29d05ca32e396ea1eb5fb01d8256b669cec7663"
+checksum = "07cdf1b148b25c1e1f7a42225e30a0d99a615cd4637eae7365548dd4529b95bc"
 dependencies = [
 "anstream",
 "anstyle",
@ -479,7 +479,7 @@ dependencies = [
 "heck",
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -681,6 +681,30 @@ version = "2.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2e66c9d817f1720209181c316d28635c050fa304f9c79e47a520882661b7308"

+[[package]]
+name = "databake"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "959b676312ba1aaafb2219c475560082e6b20c3bc572ec1483f93cecd748cf3d"
+dependencies = [
+ "databake-derive",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
+[[package]]
+name = "databake-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f0694dfe255f1af0289d3d1b40787bb955e8603d96e96a6b14b225926e108fb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "synstructure",
+]
+
 [[package]]
 name = "deranged"
 version = "0.3.9"
@ -702,7 +726,7 @@ dependencies = [
 "quote",
 "serde",
 "serde_tokenstream",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -716,7 +740,7 @@ dependencies = [
 "quote",
 "serde",
 "serde_tokenstream",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -975,7 +999,7 @@ checksum = "53b153fd91e4b0147f4aced87be237c98248656bb01050b96bf3ee89220a8ddb"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -1383,9 +1407,9 @@ dependencies = [

 [[package]]
 name = "js-sys"
-version = "0.3.64"
+version = "0.3.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
+checksum = "54c0c35952f67de54bb584e9fd912b3023117cbafc0a77d8f3dee1fb5f572fe8"
 dependencies = [
 "wasm-bindgen",
 ]
@ -1412,6 +1436,7 @@ dependencies = [
 "clap",
 "criterion",
 "dashmap",
+ "databake",
 "derive-docs 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
 "expectorate",
 "futures",
@ -1438,6 +1463,18 @@ dependencies = [
 "winnow",
 ]

+[[package]]
+name = "kcl-macros"
+version = "0.1.0"
+dependencies = [
+ "databake",
+ "kcl-lib",
+ "pretty_assertions",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+]
+
 [[package]]
 name = "kittycad"
 version = "0.2.41"
@ -1893,7 +1930,7 @@ dependencies = [
 "regex",
 "regex-syntax 0.7.5",
 "structmeta",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -1946,7 +1983,7 @@ checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2558,9 +2595,9 @@ checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090"

 [[package]]
 name = "serde"
-version = "1.0.190"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7"
+checksum = "bca2a08484b285dcb282d0f67b26cadc0df8b19f8c12502c13d966bf9482f001"
 dependencies = [
 "serde_derive",
 ]
@ -2576,13 +2613,13 @@ dependencies = [

 [[package]]
 name = "serde_derive"
-version = "1.0.190"
+version = "1.0.192"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3"
+checksum = "d6c7207fbec9faa48073f3e3074cbe553af6ea512d7c21ba46e434e70ea9fbc1"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2616,7 +2653,7 @@ checksum = "8725e1dfadb3a50f7e5ce0b1a540466f6ed3fe7a0fca2ac2b8b831d31316bd00"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2637,7 +2674,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "serde",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2848,7 +2885,7 @@ dependencies = [
 "proc-macro2",
 "quote",
 "structmeta-derive",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2859,7 +2896,7 @@ checksum = "a60bcaff7397072dca0017d1db428e30d5002e00b6847703e2e42005c95fbe00"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -2897,15 +2934,27 @@ dependencies = [

 [[package]]
 name = "syn"
-version = "2.0.38"
+version = "2.0.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
+checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-ident",
 ]

+[[package]]
+name = "synstructure"
+version = "0.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "285ba80e733fac80aa4270fbcdf83772a79b80aa35c97075320abfee4a915b06"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.39",
+ "unicode-xid",
+]
+
 [[package]]
 name = "system-configuration"
 version = "0.5.1"
@ -3008,7 +3057,7 @@ checksum = "266b2e40bc00e5a6c09c3584011e08b06f123c00362c92b975ba9843aaaa14b8"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -3090,9 +3139,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"

 [[package]]
 name = "tokio"
-version = "1.33.0"
+version = "1.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f38200e3ef7995e5ef13baec2f432a6da0aa9ac495b2c0e8f3b7eec2c92d653"
+checksum = "d0c014766411e834f7af5b8f4cf46257aab4036ca95e9d2c144a10f59ad6f5b9"
 dependencies = [
 "backtrace",
 "bytes",
@ -3109,13 +3158,13 @@ dependencies = [

 [[package]]
 name = "tokio-macros"
-version = "2.1.0"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
+checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -3256,7 +3305,7 @@ checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -3284,7 +3333,7 @@ checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
@ -3370,7 +3419,7 @@ dependencies = [
 "Inflector",
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 "termcolor",
 ]

@ -3455,6 +3504,12 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"

+[[package]]
+name = "unicode-xid"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
+
 [[package]]
 name = "unsafe-libyaml"
 version = "0.2.9"
@ -3548,9 +3603,9 @@ checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"

 [[package]]
 name = "wasm-bindgen"
-version = "0.2.87"
+version = "0.2.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
+checksum = "7daec296f25a1bae309c0cd5c29c4b260e510e6d813c286b19eaadf409d40fce"
 dependencies = [
 "cfg-if",
 "wasm-bindgen-macro",
@ -3558,24 +3613,24 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.87"
+version = "0.2.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
+checksum = "e397f4664c0e4e428e8313a469aaa58310d302159845980fd23b0f22a847f217"
 dependencies = [
 "bumpalo",
 "log",
 "once_cell",
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 "wasm-bindgen-shared",
 ]

 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.37"
+version = "0.4.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03"
+checksum = "9afec9963e3d0994cac82455b2b3502b81a7f40f9a0d32181f7528d9f4b43e02"
 dependencies = [
 "cfg-if",
 "futures-core",
@ -3586,9 +3641,9 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.87"
+version = "0.2.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
+checksum = "5961017b3b08ad5f3fe39f1e79877f8ee7c23c5e5fd5eb80de95abc41f1f16b2"
 dependencies = [
 "quote",
 "wasm-bindgen-macro-support",
@ -3596,22 +3651,22 @@ dependencies = [

 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.87"
+version = "0.2.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
+checksum = "c5353b8dab669f5e10f5bd76df26a9360c748f054f862ff5f3f8aae0c7fb3907"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 "wasm-bindgen-backend",
 "wasm-bindgen-shared",
 ]

 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.87"
+version = "0.2.88"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
+checksum = "0d046c5d029ba91a1ed14da14dca44b68bf2f124cfbaf741c54151fdb3e0750b"

 [[package]]
 name = "wasm-lib"
@ -3668,9 +3723,9 @@ dependencies = [

 [[package]]
 name = "web-sys"
-version = "0.3.64"
+version = "0.3.65"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
+checksum = "5db499c5f66323272151db0e666cd34f78617522fb0c1604d31a27c50c206a85"
 dependencies = [
 "js-sys",
 "wasm-bindgen",
@ -3862,9 +3917,9 @@ checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"

 [[package]]
 name = "winnow"
-version = "0.5.18"
+version = "0.5.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "176b6138793677221d420fd2f0aeeced263f197688b36484660da767bca2fa32"
+checksum = "829846f3e3db426d4cee4510841b71a8e58aa2a76b1132579487ae430ccd9c7b"
 dependencies = [
 "memchr",
 ]
@ -3920,7 +3975,7 @@ checksum = "6b6093bc6d5265ff40b479c834cdd25d8e20784781a2a29a8106327393d0a9ff"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.38",
+ "syn 2.0.39",
 ]

 [[package]]
--- a/src/wasm-lib/Cargo.toml
+++ b/src/wasm-lib/Cargo.toml
@ -3,6 +3,7 @@ name = "wasm-lib"
 version = "0.1.0"
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-app"
+rust-version = "1.73"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 [lib]
@ -15,8 +16,8 @@ kcl-lib = { path = "kcl" }
 kittycad = { workspace = true }
 serde_json = "1.0.108"
 uuid = { version = "1.5.0", features = ["v4", "js", "serde"] }
-wasm-bindgen = "0.2.87"
-wasm-bindgen-futures = "0.4.37"
+wasm-bindgen = "0.2.88"
+wasm-bindgen-futures = "0.4.38"

 [dev-dependencies]
 anyhow = "1"
@ -24,19 +25,19 @@ image = "0.24.7"
 kittycad = { workspace = true, default-features = true }
 pretty_assertions = "1.4.0"
 reqwest = { version = "0.11.22", default-features = false }
-tokio = { version = "1.33.0", features = ["rt-multi-thread", "macros", "time"] }
+tokio = { version = "1.34.0", features = ["rt-multi-thread", "macros", "time"] }
 twenty-twenty = "0.6.1"
 uuid = { version = "1.5.0", features = ["v4", "js", "serde"] }

 [target.'cfg(target_arch = "wasm32")'.dependencies]
 futures = "0.3.29"
-js-sys = "0.3.64"
+js-sys = "0.3.65"
 tower-lsp = { version = "0.20.0", default-features = false, features = ["runtime-agnostic"] }
 wasm-bindgen-futures = { version = "0.4.37", features = ["futures-core-03-stream"] }
 wasm-streams = "0.4.0"

 [target.'cfg(target_arch = "wasm32")'.dependencies.web-sys]
-version = "0.3.57"
+version = "0.3.65"
 features = [
  "console",
  "HtmlTextAreaElement",
@ -52,6 +53,7 @@ debug = true
 members = [
 	"derive-docs",
 	"kcl",
+  "kcl-macros",
 ]

 [workspace.dependencies]
--- a/src/wasm-lib/derive-docs/Cargo.toml
+++ b/src/wasm-lib/derive-docs/Cargo.toml
@ -5,6 +5,7 @@ version = "0.1.4"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
+rust-version = "1.73"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -15,9 +16,9 @@ proc-macro = true
 convert_case = "0.6.0"
 proc-macro2 = "1"
 quote = "1"
-serde = { version = "1.0.190", features = ["derive"] }
+serde = { version = "1.0.192", features = ["derive"] }
 serde_tokenstream = "0.2"
-syn = { version = "2.0.38", features = ["full"] }
+syn = { version = "2.0.39", features = ["full"] }

 [dev-dependencies]
 expectorate = "1.1.0"
--- a/src/wasm-lib/kcl-macros/Cargo.toml
+++ b/src/wasm-lib/kcl-macros/Cargo.toml
@ -0,0 +1,22 @@
+[package]
+name = "kcl-macros"
+description = "Macro for compiling KCL to its AST during Rust compile-time"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/KittyCAD/modeling-app"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+databake = "0.1.6"
+kcl-lib = { path = "../kcl" }
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "2.0.39", features = ["full"] }
+
+[dev-dependencies]
+pretty_assertions = "1.4.0"
--- a/src/wasm-lib/kcl-macros/src/lib.rs
+++ b/src/wasm-lib/kcl-macros/src/lib.rs
@ -0,0 +1,22 @@
+use databake::*;
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, LitStr};
+
+/// Parses KCL into its AST at compile-time.
+/// This macro takes exactly one argument: A string literal containing KCL.
+/// # Examples
+/// ```
+/// extern crate alloc;
+/// use kcl_compile_macro::parse_kcl;
+/// let ast: kcl_lib::ast::types::Program = parse_kcl!("const y = 4");
+/// ```
+#[proc_macro]
+pub fn parse(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as LitStr);
+    let kcl_src = input.value();
+    let tokens = kcl_lib::token::lexer(&kcl_src);
+    let ast = kcl_lib::parser::Parser::new(tokens).ast().unwrap();
+    let ast_struct = ast.bake(&Default::default());
+    quote!(#ast_struct).into()
+}
--- a/src/wasm-lib/kcl-macros/tests/macro_test.rs
+++ b/src/wasm-lib/kcl-macros/tests/macro_test.rs
@ -0,0 +1,38 @@
+extern crate alloc;
+use kcl_lib::ast::types::{
+    BodyItem, Identifier, Literal, LiteralValue, NonCodeMeta, Program, Value, VariableDeclaration, VariableDeclarator,
+    VariableKind,
+};
+use kcl_macros::parse;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn basic() {
+    let actual = parse!("const y = 4");
+    let expected = Program {
+        start: 0,
+        end: 11,
+        body: vec![BodyItem::VariableDeclaration(VariableDeclaration {
+            start: 0,
+            end: 11,
+            declarations: vec![VariableDeclarator {
+                start: 6,
+                end: 11,
+                id: Identifier {
+                    start: 6,
+                    end: 7,
+                    name: "y".to_owned(),
+                },
+                init: Value::Literal(Box::new(Literal {
+                    start: 10,
+                    end: 11,
+                    value: LiteralValue::IInteger(4),
+                    raw: "4".to_owned(),
+                })),
+            }],
+            kind: VariableKind::Const,
+        })],
+        non_code_meta: NonCodeMeta::default(),
+    };
+    assert_eq!(expected, actual);
+}
--- a/src/wasm-lib/kcl/Cargo.toml
+++ b/src/wasm-lib/kcl/Cargo.toml
@ -5,6 +5,7 @@ version = "0.1.35"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/KittyCAD/modeling-app"
+rust-version = "1.73"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

@ -12,15 +13,16 @@ repository = "https://github.com/KittyCAD/modeling-app"
 anyhow = { version = "1.0.75", features = ["backtrace"] }
 async-recursion = "1.0.5"
 async-trait = "0.1.73"
-clap = { version = "4.4.7", features = ["cargo", "derive", "env", "unicode"], optional = true }
+clap = { version = "4.4.8", features = ["cargo", "derive", "env", "unicode"], optional = true }
 dashmap = "5.5.3"
+databake = { version = "0.1.6", features = ["derive"] }
 derive-docs = { version = "0.1.4" }
 #derive-docs = { path = "../derive-docs" }
 kittycad = { workspace = true }
 lazy_static = "1.4.0"
 parse-display = "0.8.2"
 schemars = { version = "0.8", features = ["impl_json_schema", "url", "uuid1"] }
-serde = { version = "1.0.190", features = ["derive"] }
+serde = { version = "1.0.192", features = ["derive"] }
 serde_json = "1.0.108"
 thiserror = "1.0.50"
 ts-rs = { version = "7", package = "ts-rs-json-value", features = ["serde-json-impl", "schemars-impl", "uuid-impl"] }
@ -28,17 +30,17 @@ uuid = { version = "1.5.0", features = ["v4", "js", "serde"] }
 winnow = "0.5.18"

 [target.'cfg(target_arch = "wasm32")'.dependencies]
-js-sys = { version = "0.3.64" }
+js-sys = { version = "0.3.65" }
 tower-lsp = { version = "0.20.0", default-features = false, features = ["runtime-agnostic"] }
-wasm-bindgen = "0.2.87"
-wasm-bindgen-futures = "0.4.37"
-web-sys = { version = "0.3.64", features = ["console"] }
+wasm-bindgen = "0.2.88"
+wasm-bindgen-futures = "0.4.38"
+web-sys = { version = "0.3.65", features = ["console"] }

 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 bson = { version = "2.7.0", features = ["uuid-1", "chrono"] }
 futures = { version = "0.3.29" }
 reqwest = { version = "0.11.22", default-features = false }
-tokio = { version = "1.33.0", features = ["full"] }
+tokio = { version = "1.34.0", features = ["full"] }
 tokio-tungstenite = { version = "0.20.0", features = ["rustls-tls-native-roots"] }
 tower-lsp = { version = "0.20.0", features = ["proposed"] }

@ -60,7 +62,7 @@ expectorate = "1.1.0"
 insta = { version = "1.34.0", features = ["json"] }
 itertools = "0.11.0"
 pretty_assertions = "1.4.0"
-tokio = { version = "1.33.0", features = ["rt-multi-thread", "macros", "time"] }
+tokio = { version = "1.34.0", features = ["rt-multi-thread", "macros", "time"] }

 [[bench]]
 name = "compiler_benchmark"
--- a/src/wasm-lib/kcl/fuzz/Cargo.toml
+++ b/src/wasm-lib/kcl/fuzz/Cargo.toml
@ -4,6 +4,7 @@ version = "0.0.0"
 publish = false
 edition = "2021"
 repository = "https://github.com/KittyCAD/modeling-app"
+rust-version = "1.73"

 [package.metadata]
 cargo-fuzz = true
--- a/src/wasm-lib/kcl/src/ast/types.rs
+++ b/src/wasm-lib/kcl/src/ast/types.rs
@ -3,23 +3,26 @@
 use std::{collections::HashMap, fmt::Write};

 use anyhow::Result;
+use databake::*;
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
-use serde_json::Map;
-use serde_json::Value as JValue;
+use serde_json::{Map, Value as JValue};
 use tower_lsp::lsp_types::{CompletionItem, CompletionItemKind, DocumentSymbol, Range as LspRange, SymbolKind};

 pub use self::literal_value::LiteralValue;
 use crate::{
+    docs::StdLibFn,
    errors::{KclError, KclErrorDetails},
-    executor::{ExecutorContext, MemoryItem, Metadata, PipeInfo, ProgramMemory, SourceRange, UserVal},
+    executor::{BodyType, ExecutorContext, MemoryItem, Metadata, PipeInfo, ProgramMemory, SourceRange, UserVal},
    parser::PIPE_OPERATOR,
+    std::{kcl_stdlib::KclStdLibFn, FunctionKind},
 };

 mod literal_value;

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
 pub struct Program {
@ -348,7 +351,8 @@ macro_rules! impl_value_meta {

 pub(crate) use impl_value_meta;

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum BodyItem {
@ -387,7 +391,8 @@ impl From<&BodyItem> for SourceRange {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum Value {
@ -550,7 +555,8 @@ impl From<&Value> for SourceRange {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum BinaryPart {
@ -706,7 +712,8 @@ impl BinaryPart {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct NonCodeNode {
@ -754,7 +761,8 @@ impl NonCodeNode {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase")]
 pub enum CommentStyle {
@ -764,7 +772,8 @@ pub enum CommentStyle {
    Block,
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type", rename_all = "camelCase")]
 pub enum NonCodeValue {
@ -809,6 +818,19 @@ pub struct NonCodeMeta {
    pub start: Vec<NonCodeNode>,
 }

+impl Bake for NonCodeMeta {
+    fn bake(&self, env: &CrateEnv) -> TokenStream {
+        env.insert("kcl_lib::ast::types");
+        let start = self.start.bake(env);
+        databake::quote! {
+            kcl_lib::ast::types::NonCodeMeta {
+                non_code_nodes: std::collections::HashMap::new(),
+                start: #start,
+            }
+        }
+    }
+}
+
 // implement Deserialize manually because we to force the keys of non_code_nodes to be usize
 // and by default the ts type { [statementIndex: number]: NonCodeNode } serializes to a string i.e. "0", "1", etc.
 impl<'de> Deserialize<'de> for NonCodeMeta {
@ -842,7 +864,8 @@ impl NonCodeMeta {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ExpressionStatement {
@ -853,7 +876,8 @@ pub struct ExpressionStatement {

 impl_value_meta!(ExpressionStatement);

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct CallExpression {
@ -862,7 +886,6 @@ pub struct CallExpression {
    pub callee: Identifier,
    pub arguments: Vec<Value>,
    pub optional: bool,
-    pub function: Function,
 }

 impl_value_meta!(CallExpression);
@ -875,22 +898,12 @@ impl From<CallExpression> for Value {

 impl CallExpression {
    pub fn new(name: &str, arguments: Vec<Value>) -> Result<Self, KclError> {
-        // Create our stdlib.
-        let stdlib = crate::std::StdLib::new();
-        let func = stdlib.get(name).ok_or_else(|| {
-            KclError::UndefinedValue(KclErrorDetails {
-                message: format!("Function {} is not defined", name),
-                source_ranges: vec![],
-            })
-        })?;
-
        Ok(Self {
            start: 0,
            end: 0,
            callee: Identifier::new(name),
            arguments,
            optional: false,
-            function: Function::StdLib { func },
        })
    }

@ -972,8 +985,8 @@ impl CallExpression {
            fn_args.push(result);
        }

-        match &self.function {
-            Function::StdLib { func } => {
+        match ctx.stdlib.get_either(&self.callee.name) {
+            FunctionKind::Core(func) => {
                // Attempt to call the function.
                let args = crate::std::Args::new(fn_args, self.into(), ctx.clone());
                let result = func.std_lib_fn()(args).await?;
@ -985,14 +998,54 @@ impl CallExpression {
                    Ok(result)
                }
            }
-            Function::InMemory => {
+            FunctionKind::Std(func) => {
+                let function_expression = func.function();
+                if fn_args.len() != function_expression.params.len() {
+                    return Err(KclError::Semantic(KclErrorDetails {
+                        message: format!(
+                            "Expected {} arguments, got {}",
+                            function_expression.params.len(),
+                            fn_args.len(),
+                        ),
+                        source_ranges: vec![(function_expression).into()],
+                    }));
+                }
+
+                // Add the arguments to the memory.
+                let mut fn_memory = memory.clone();
+                for (index, param) in function_expression.params.iter().enumerate() {
+                    fn_memory.add(&param.name, fn_args.get(index).unwrap().clone(), param.into())?;
+                }
+
+                // Call the stdlib function
+                let p = func.function().clone().body;
+                let results = crate::executor::execute(p, &mut fn_memory, BodyType::Block, ctx).await?;
+                let out = results.return_;
+                let result = out.ok_or_else(|| {
+                    KclError::UndefinedValue(KclErrorDetails {
+                        message: format!("Result of stdlib function {} is undefined", fn_name),
+                        source_ranges: vec![self.into()],
+                    })
+                })?;
+                let result = result.get_value()?;
+
+                if pipe_info.is_in_pipe {
+                    pipe_info.index += 1;
+                    pipe_info.previous_results.push(result);
+
+                    execute_pipe_body(memory, &pipe_info.body.clone(), pipe_info, self.into(), ctx).await
+                } else {
+                    Ok(result)
+                }
+            }
+            FunctionKind::UserDefined => {
                let func = memory.get(&fn_name, self.into())?;
                let result = func
                    .call_fn(fn_args, memory.clone(), ctx.clone())
                    .await?
                    .ok_or_else(|| {
                        KclError::UndefinedValue(KclErrorDetails {
-                            message: format!("Result of function {} is undefined", fn_name),
+                            message: format!("Result of user-defined function {} is undefined", fn_name),
                            source_ranges: vec![self.into()],
                        })
                    })?;
@ -1067,10 +1120,15 @@ impl CallExpression {
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum Function {
-    /// A stdlib function.
+    /// A stdlib function written in Rust (aka core lib).
    StdLib {
        /// The function.
-        func: Box<dyn crate::docs::StdLibFn>,
+        func: Box<dyn StdLibFn>,
+    },
+    /// A stdlib function written in KCL.
+    StdLibKcl {
+        /// The function.
+        func: Box<dyn KclStdLibFn>,
    },
    /// A function that is defined in memory.
    #[default]
@ -1087,7 +1145,8 @@ impl PartialEq for Function {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct VariableDeclaration {
@ -1237,7 +1296,8 @@ impl VariableDeclaration {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@ -1281,7 +1341,8 @@ impl VariableKind {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct VariableDeclarator {
@ -1310,7 +1371,8 @@ impl VariableDeclarator {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct Literal {
@ -1380,7 +1442,8 @@ impl From<&Box<Literal>> for MemoryItem {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct Identifier {
@ -1416,7 +1479,8 @@ impl Identifier {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct PipeSubstitution {
@ -1444,7 +1508,8 @@ impl From<PipeSubstitution> for Value {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ArrayExpression {
@ -1604,7 +1669,8 @@ impl ArrayExpression {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ObjectExpression {
@ -1761,7 +1827,8 @@ impl ObjectExpression {

 impl_value_meta!(ObjectExpression);

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ObjectProperty {
@ -1803,7 +1870,8 @@ impl ObjectProperty {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum MemberObject {
@ -1849,7 +1917,8 @@ impl From<&MemberObject> for SourceRange {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub enum LiteralIdentifier {
@ -1885,7 +1954,8 @@ impl From<&LiteralIdentifier> for SourceRange {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct MemberExpression {
@ -2048,7 +2118,8 @@ pub struct ObjectKeyInfo {
    pub computed: bool,
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct BinaryExpression {
@ -2227,7 +2298,8 @@ pub fn parse_json_value_as_string(j: &serde_json::Value) -> Option<String> {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@ -2295,7 +2367,8 @@ impl BinaryOperator {
        }
    }
 }
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct UnaryExpression {
@ -2373,7 +2446,8 @@ impl UnaryExpression {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, FromStr, Display, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "snake_case")]
 #[display(style = "snake_case")]
@ -2388,7 +2462,8 @@ pub enum UnaryOperator {
    Not,
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(rename_all = "camelCase", tag = "type")]
 pub struct PipeExpression {
@ -2546,7 +2621,8 @@ async fn execute_pipe_body(
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct FunctionExpression {
@ -2596,7 +2672,8 @@ impl FunctionExpression {
    }
 }

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(tag = "type")]
 pub struct ReturnStatement {
--- a/src/wasm-lib/kcl/src/ast/types/literal_value.rs
+++ b/src/wasm-lib/kcl/src/ast/types/literal_value.rs
@ -1,10 +1,12 @@
+use databake::*;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use serde_json::Value as JValue;

 use super::{Literal, Value};

-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema, Bake)]
+#[databake(path = kcl_lib::ast::types)]
 #[ts(export)]
 #[serde(untagged, rename_all = "snake_case")]
 pub enum LiteralValue {
--- a/src/wasm-lib/kcl/src/errors.rs
+++ b/src/wasm-lib/kcl/src/errors.rs
@ -28,6 +28,8 @@ pub enum KclError {
    InvalidExpression(KclErrorDetails),
    #[error("engine: {0:?}")]
    Engine(KclErrorDetails),
+    #[error("internal error, please report to KittyCAD team: {0:?}")]
+    Internal(KclErrorDetails),
 }

 #[derive(Debug, Serialize, Deserialize, ts_rs::TS, Clone)]
@ -42,21 +44,8 @@ pub struct KclErrorDetails {
 impl KclError {
    /// Get the error message, line and column from the error and input code.
    pub fn get_message_line_column(&self, input: &str) -> (String, Option<usize>, Option<usize>) {
-        let (type_, source_range, message) = match &self {
-            KclError::Lexical(e) => ("lexical", e.source_ranges.clone(), e.message.clone()),
-            KclError::Syntax(e) => ("syntax", e.source_ranges.clone(), e.message.clone()),
-            KclError::Semantic(e) => ("semantic", e.source_ranges.clone(), e.message.clone()),
-            KclError::Type(e) => ("type", e.source_ranges.clone(), e.message.clone()),
-            KclError::Unimplemented(e) => ("unimplemented", e.source_ranges.clone(), e.message.clone()),
-            KclError::Unexpected(e) => ("unexpected", e.source_ranges.clone(), e.message.clone()),
-            KclError::ValueAlreadyDefined(e) => ("value already defined", e.source_ranges.clone(), e.message.clone()),
-            KclError::UndefinedValue(e) => ("undefined value", e.source_ranges.clone(), e.message.clone()),
-            KclError::InvalidExpression(e) => ("invalid expression", e.source_ranges.clone(), e.message.clone()),
-            KclError::Engine(e) => ("engine", e.source_ranges.clone(), e.message.clone()),
-        };
-
        // Calculate the line and column of the error from the source range.
-        let (line, column) = if let Some(range) = source_range.first() {
+        let (line, column) = if let Some(range) = self.source_ranges().first() {
            let line = input[..range.0[0]].lines().count();
            let column = input[..range.0[0]].lines().last().map(|l| l.len()).unwrap_or_default();

@ -65,7 +54,23 @@ impl KclError {
            (None, None)
        };

-        (format!("{}: {}", type_, message), line, column)
+        (format!("{}: {}", self.error_type(), self.message()), line, column)
+    }
+
+    pub fn error_type(&self) -> &'static str {
+        match self {
+            KclError::Lexical(_) => "lexical",
+            KclError::Syntax(_) => "syntax",
+            KclError::Semantic(_) => "semantic",
+            KclError::Type(_) => "type",
+            KclError::Unimplemented(_) => "unimplemented",
+            KclError::Unexpected(_) => "unexpected",
+            KclError::ValueAlreadyDefined(_) => "value already defined",
+            KclError::UndefinedValue(_) => "undefined value",
+            KclError::InvalidExpression(_) => "invalid expression",
+            KclError::Engine(_) => "engine",
+            KclError::Internal(_) => "internal",
+        }
    }

    pub fn source_ranges(&self) -> Vec<SourceRange> {
@ -80,6 +85,7 @@ impl KclError {
            KclError::UndefinedValue(e) => e.source_ranges.clone(),
            KclError::InvalidExpression(e) => e.source_ranges.clone(),
            KclError::Engine(e) => e.source_ranges.clone(),
+            KclError::Internal(e) => e.source_ranges.clone(),
        }
    }

@ -96,6 +102,7 @@ impl KclError {
            KclError::UndefinedValue(e) => &e.message,
            KclError::InvalidExpression(e) => &e.message,
            KclError::Engine(e) => &e.message,
+            KclError::Internal(e) => &e.message,
        }
    }

--- a/src/wasm-lib/kcl/src/executor.rs
+++ b/src/wasm-lib/kcl/src/executor.rs
@ -1,8 +1,9 @@
 //! The executor for the AST.

-use std::collections::HashMap;
+use std::{collections::HashMap, sync::Arc};

 use anyhow::Result;
+use async_recursion::async_recursion;
 use kittycad::types::{Color, ModelingCmd, Point3D};
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
@ -10,9 +11,10 @@ use serde::{Deserialize, Serialize};
 use tower_lsp::lsp_types::{Position as LspPosition, Range as LspRange};

 use crate::{
-    ast::types::{BodyItem, Function, FunctionExpression, Value},
+    ast::types::{BodyItem, FunctionExpression, Value},
    engine::{EngineConnection, EngineManager},
    errors::{KclError, KclErrorDetails},
+    std::{FunctionKind, StdLib},
 };

 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
@ -347,27 +349,27 @@ impl MemoryItem {
        }
    }

+    /// If this memory item is a function, call it with the given arguments, return its val as Ok.
+    /// If it's not a function, return Err.
    pub async fn call_fn(
        &self,
        args: Vec<MemoryItem>,
        memory: ProgramMemory,
        ctx: ExecutorContext,
    ) -> Result<Option<ProgramReturn>, KclError> {
-        if let MemoryItem::Function { func, expression, meta } = &self {
-            if let Some(func) = func {
-                func(args, memory, expression.clone(), meta.clone(), ctx).await
-            } else {
-                Err(KclError::Semantic(KclErrorDetails {
-                    message: format!("Not a function: {:?}", expression),
-                    source_ranges: vec![],
-                }))
-            }
-        } else {
-            Err(KclError::Semantic(KclErrorDetails {
+        let MemoryItem::Function { func, expression, meta } = &self else {
+            return Err(KclError::Semantic(KclErrorDetails {
                message: "not a in memory function".to_string(),
                source_ranges: vec![],
-            }))
-        }
+            }));
+        };
+        let Some(func) = func else {
+            return Err(KclError::Semantic(KclErrorDetails {
+                message: format!("Not a function: {:?}", expression),
+                source_ranges: vec![],
+            }));
+        };
+        func(args, memory, expression.clone(), meta.clone(), ctx).await
    }
 }

@ -776,9 +778,11 @@ impl Default for PipeInfo {
 pub struct ExecutorContext {
    pub engine: EngineConnection,
    pub planes: DefaultPlanes,
+    pub stdlib: Arc<StdLib>,
 }

 /// Execute a AST's program.
+#[async_recursion(?Send)]
 pub async fn execute(
    program: crate::ast::types::Program,
    memory: &mut ProgramMemory,
@ -791,7 +795,9 @@ pub async fn execute(
    for statement in &program.body {
        match statement {
            BodyItem::ExpressionStatement(expression_statement) => {
-                if let Value::CallExpression(call_expr) = &expression_statement.expression {
+                if let Value::PipeExpression(pipe_expr) = &expression_statement.expression {
+                    pipe_expr.get_result(memory, &mut pipe_info, ctx).await?;
+                } else if let Value::CallExpression(call_expr) = &expression_statement.expression {
                    let fn_name = call_expr.callee.name.to_string();
                    let mut args: Vec<MemoryItem> = Vec::new();
                    for arg in &call_expr.arguments {
@ -826,24 +832,37 @@ pub async fn execute(
                        }
                    }
                    let _show_fn = Box::new(crate::std::Show);
-                    if let Function::StdLib { func: _show_fn } = &call_expr.function {
-                        if options != BodyType::Root {
-                            return Err(KclError::Semantic(KclErrorDetails {
-                                message: "Cannot call show outside of a root".to_string(),
-                                source_ranges: vec![call_expr.into()],
-                            }));
+                    match ctx.stdlib.get_either(&call_expr.callee.name) {
+                        FunctionKind::Core(func) => {
+                            use crate::docs::StdLibFn;
+                            if func.name() == _show_fn.name() {
+                                if options != BodyType::Root {
+                                    return Err(KclError::Semantic(KclErrorDetails {
+                                        message: "Cannot call show outside of a root".to_string(),
+                                        source_ranges: vec![call_expr.into()],
+                                    }));
+                                }
+
+                                memory.return_ = Some(ProgramReturn::Arguments(call_expr.arguments.clone()));
+                            }
                        }
+                        FunctionKind::Std(func) => {
+                            let mut newmem = memory.clone();
+                            let result = execute(func.program().to_owned(), &mut newmem, BodyType::Block, ctx).await?;
+                            memory.return_ = result.return_;
+                        }
+                        FunctionKind::UserDefined => {
+                            if let Some(func) = memory.clone().root.get(&fn_name) {
+                                let result = func.call_fn(args.clone(), memory.clone(), ctx.clone()).await?;

-                        memory.return_ = Some(ProgramReturn::Arguments(call_expr.arguments.clone()));
-                    } else if let Some(func) = memory.clone().root.get(&fn_name) {
-                        let result = func.call_fn(args.clone(), memory.clone(), ctx.clone()).await?;
-
-                        memory.return_ = result;
-                    } else {
-                        return Err(KclError::Semantic(KclErrorDetails {
-                            message: format!("No such name {} defined", fn_name),
-                            source_ranges: vec![call_expr.into()],
-                        }));
+                                memory.return_ = result;
+                            } else {
+                                return Err(KclError::Semantic(KclErrorDetails {
+                                    message: format!("No such name {} defined", fn_name),
+                                    source_ranges: vec![call_expr.into()],
+                                }));
+                            }
+                        }
                    }
                }
            }
@ -1011,7 +1030,11 @@ mod tests {
        let mut mem: ProgramMemory = Default::default();
        let engine = EngineConnection::new().await?;
        let planes = DefaultPlanes::new(&engine).await?;
-        let ctx = ExecutorContext { engine, planes };
+        let ctx = ExecutorContext {
+            engine,
+            planes,
+            stdlib: Arc::new(StdLib::default()),
+        };
        let memory = execute(program, &mut mem, BodyType::Root, &ctx).await?;

        Ok(memory)
--- a/src/wasm-lib/kcl/src/parser.rs
+++ b/src/wasm-lib/kcl/src/parser.rs
@ -36,13 +36,13 @@ impl Parser {

        if !self.unknown_tokens.is_empty() {
            let source_ranges = self.unknown_tokens.iter().map(SourceRange::from).collect();
-            return Err(KclError::Lexical(KclErrorDetails {
-                source_ranges,
-                message: format!(
-                    "found unknown tokens {:?}",
-                    self.unknown_tokens.iter().map(|t| t.value.as_str()).collect::<Vec<_>>()
-                ),
-            }));
+            let token_list = self.unknown_tokens.iter().map(|t| t.value.as_str()).collect::<Vec<_>>();
+            let message = if token_list.len() == 1 {
+                format!("found unknown token '{}'", token_list[0])
+            } else {
+                format!("found unknown tokens [{}]", token_list.join(", "))
+            };
+            return Err(KclError::Lexical(KclErrorDetails { source_ranges, message }));
        }

        parser_impl::run_parser(&mut self.tokens.as_slice())
--- a/src/wasm-lib/kcl/src/parser/math.rs
+++ b/src/wasm-lib/kcl/src/parser/math.rs
@ -1,20 +1,33 @@
-use crate::ast::types::{BinaryExpression, BinaryOperator, BinaryPart};
+use crate::{
+    ast::types::{BinaryExpression, BinaryOperator, BinaryPart},
+    errors::{KclError, KclErrorDetails},
+    executor::SourceRange,
+};

 /// Parses a list of tokens (in infix order, i.e. as the user typed them)
 /// into a binary expression tree.
-pub fn parse(infix_tokens: Vec<BinaryExpressionToken>) -> BinaryExpression {
+pub fn parse(infix_tokens: Vec<BinaryExpressionToken>) -> Result<BinaryExpression, KclError> {
    let rpn = postfix(infix_tokens);
    evaluate(rpn)
 }

 /// Parses a list of tokens (in postfix order) into a binary expression tree.
-fn evaluate(rpn: Vec<BinaryExpressionToken>) -> BinaryExpression {
-    let mut operand_stack = Vec::new();
+fn evaluate(rpn: Vec<BinaryExpressionToken>) -> Result<BinaryExpression, KclError> {
+    let source_ranges = source_range(&rpn);
+    let mut operand_stack: Vec<BinaryPart> = Vec::new();
+    let e = KclError::Internal(KclErrorDetails {
+        source_ranges,
+        message: "error parsing binary math expressions".to_owned(),
+    });
    for item in rpn {
        let expr = match item {
            BinaryExpressionToken::Operator(operator) => {
-                let right: BinaryPart = operand_stack.pop().unwrap();
-                let left = operand_stack.pop().unwrap();
+                let Some(right) = operand_stack.pop() else {
+                    return Err(e);
+                };
+                let Some(left) = operand_stack.pop() else {
+                    return Err(e);
+                };
                BinaryPart::BinaryExpression(Box::new(BinaryExpression {
                    start: left.start(),
                    end: right.end(),
@ -27,10 +40,26 @@ fn evaluate(rpn: Vec<BinaryExpressionToken>) -> BinaryExpression {
        };
        operand_stack.push(expr)
    }
-    if let BinaryPart::BinaryExpression(expr) = operand_stack.pop().unwrap() {
-        *expr
+    if let Some(BinaryPart::BinaryExpression(expr)) = operand_stack.pop() {
+        Ok(*expr)
    } else {
-        panic!("Last expression was not a binary expression")
+        // If this branch is used, the evaluation algorithm has a bug and must be fixed.
+        // This is a programmer error, not a user error.
+        Err(e)
+    }
+}
+
+fn source_range(tokens: &[BinaryExpressionToken]) -> Vec<SourceRange> {
+    let sources: Vec<_> = tokens
+        .iter()
+        .filter_map(|op| match op {
+            BinaryExpressionToken::Operator(_) => None,
+            BinaryExpressionToken::Operand(o) => Some((o.start(), o.end())),
+        })
+        .collect();
+    match (sources.first(), sources.last()) {
+        (Some((start, _)), Some((_, end))) => vec![SourceRange([*start, *end])],
+        _ => Vec::new(),
    }
 }

@ -46,15 +75,16 @@ fn postfix(infix: Vec<BinaryExpressionToken>) -> Vec<BinaryExpressionToken> {
                //     there is an operator o2 at the top of the operator stack which is not a left parenthesis,
                //     and (o2 has greater precedence than o1 or (o1 and o2 have the same precedence and o1 is left-associative))
                // )
-                while operator_stack
-                    .last()
-                    .map(|o2| {
-                        (o2.precedence() > o1.precedence())
-                            || o1.precedence() == o2.precedence() && o1.associativity().is_left()
-                    })
-                    .unwrap_or(false)
-                {
-                    output.push(BinaryExpressionToken::Operator(operator_stack.pop().unwrap()));
+                // pop o2 from the operator stack into the output queue
+                while let Some(o2) = operator_stack.pop() {
+                    if (o2.precedence() > o1.precedence())
+                        || o1.precedence() == o2.precedence() && o1.associativity().is_left()
+                    {
+                        output.push(BinaryExpressionToken::Operator(o2));
+                    } else {
+                        operator_stack.push(o2);
+                        break;
+                    }
                }
                operator_stack.push(o1);
            }
@ -127,8 +157,7 @@ mod tests {
        ];
        for infix_input in tests {
            let rpn = postfix(infix_input);
-            let tree = evaluate(rpn);
-            dbg!(tree);
+            let _tree = evaluate(rpn).unwrap();
        }
    }
 }
--- a/src/wasm-lib/kcl/src/parser/parser_impl.rs
+++ b/src/wasm-lib/kcl/src/parser/parser_impl.rs
@ -1,11 +1,12 @@
 use winnow::{
-    combinator::{alt, delimited, opt, peek, preceded, repeat, separated0, terminated},
+    combinator::{alt, delimited, opt, peek, preceded, repeat, separated, terminated},
    dispatch,
    error::{ErrMode, StrContext, StrContextValue},
    prelude::*,
    token::{any, one_of},
 };

+use super::{math::BinaryExpressionToken, PIPE_OPERATOR, PIPE_SUBSTITUTION_OPERATOR};
 use crate::{
    ast::types::{
        ArrayExpression, BinaryExpression, BinaryOperator, BinaryPart, BodyItem, CallExpression, CommentStyle,
@ -17,20 +18,13 @@ use crate::{
    errors::{KclError, KclErrorDetails},
    executor::SourceRange,
    parser::parser_impl::error::ContextError,
-    std::StdLib,
    token::{Token, TokenType},
 };

-use super::{math::BinaryExpressionToken, PIPE_OPERATOR, PIPE_SUBSTITUTION_OPERATOR};
-
 mod error;

 type PResult<O, E = error::ContextError> = winnow::prelude::PResult<O, E>;

-lazy_static::lazy_static! {
-    static ref STDLIB: StdLib = StdLib::new();
-}
-
 type TokenSlice<'slice, 'input> = &'slice mut &'input [Token];

 pub fn run_parser(i: TokenSlice) -> Result<Program, KclError> {
@ -373,7 +367,7 @@ fn equals(i: TokenSlice) -> PResult<Token> {
 fn array(i: TokenSlice) -> PResult<ArrayExpression> {
    let start = open_bracket(i)?.start;
    ignore_whitespace(i);
-    let elements = alt((integer_range, separated0(value, comma_sep)))
+    let elements = alt((integer_range, separated(0.., value, comma_sep)))
        .context(expected(
            "array contents, either a numeric range (like 0..10) or a list of elements (like [1, 2, 3])",
        ))
@ -430,7 +424,7 @@ fn object_property(i: TokenSlice) -> PResult<ObjectProperty> {
 fn object(i: TokenSlice) -> PResult<ObjectExpression> {
    let start = open_brace(i)?.start;
    ignore_whitespace(i);
-    let properties = separated0(object_property, comma_sep)
+    let properties = separated(0.., object_property, comma_sep)
        .context(expected(
            "a comma-separated list of key-value pairs, e.g. 'height: 4, width: 3'",
        ))
@ -1039,7 +1033,8 @@ fn binary_expression(i: TokenSlice) -> PResult<BinaryExpression> {

    // Pass the token slice into the specialized math parser, for things like
    // precedence and converting infix operations to an AST.
-    Ok(super::math::parse(tokens))
+    let expr = super::math::parse(tokens).map_err(|e| ErrMode::Backtrack(e.into()))?;
+    Ok(expr)
 }

 fn binary_expr_in_parens(i: TokenSlice) -> PResult<BinaryExpression> {
@ -1208,7 +1203,7 @@ fn comma_sep(i: TokenSlice) -> PResult<()> {

 /// Arguments are passed into a function.
 fn arguments(i: TokenSlice) -> PResult<Vec<Value>> {
-    separated0(value, comma_sep)
+    separated(0.., value, comma_sep)
        .context(expected("function arguments"))
        .parse_next(i)
 }
@ -1221,7 +1216,7 @@ fn not_close_paren(i: TokenSlice) -> PResult<Token> {
 /// Parameters are declared in a function signature, and used within a function.
 fn parameters(i: TokenSlice) -> PResult<Vec<Identifier>> {
    // Get all tokens until the next ), because that ends the parameter list.
-    let candidates: Vec<Token> = separated0(not_close_paren, comma_sep)
+    let candidates: Vec<Token> = separated(0.., not_close_paren, comma_sep)
        .context(expected("function parameters"))
        .parse_next(i)?;
    // Make sure all those tokens are valid parameters.
@ -1236,7 +1231,7 @@ fn parameters(i: TokenSlice) -> PResult<Vec<Identifier>> {
 impl Identifier {
    fn into_valid_binding_name(self) -> Result<Identifier, KclError> {
        // Make sure they are not assigning a variable to a stdlib function.
-        if STDLIB.fns.contains_key(&self.name) {
+        if crate::std::name_in_stdlib(&self.name) {
            return Err(KclError::Syntax(KclErrorDetails {
                source_ranges: vec![SourceRange([self.start, self.end])],
                message: format!("Cannot assign a variable to a reserved keyword: {}", self.name),
@ -1260,18 +1255,12 @@ fn fn_call(i: TokenSlice) -> PResult<CallExpression> {
    let _ = terminated(open_paren, opt(whitespace)).parse_next(i)?;
    let args = arguments(i)?;
    let end = preceded(opt(whitespace), close_paren).parse_next(i)?.end;
-    let function = if let Some(stdlib_fn) = STDLIB.get(&fn_name.name) {
-        crate::ast::types::Function::StdLib { func: stdlib_fn }
-    } else {
-        crate::ast::types::Function::InMemory
-    };
    Ok(CallExpression {
        start: fn_name.start,
        end,
        callee: fn_name,
        arguments: args,
        optional: false,
-        function,
    })
 }

@ -1399,7 +1388,7 @@ const mySk1 = startSketchAt([0, 0])"#;
        let Value::PipeExpression(pipe) = val else {
            panic!("expected pipe");
        };
-        let mut noncode = dbg!(pipe.non_code_meta);
+        let mut noncode = pipe.non_code_meta;
        assert_eq!(noncode.non_code_nodes.len(), 1);
        let comment = noncode.non_code_nodes.remove(&0).unwrap().pop().unwrap();
        assert_eq!(
@ -2214,9 +2203,10 @@ const secondExtrude = startSketchOn('XY')
        let tokens = crate::token::lexer(">!");
        let parser = crate::parser::Parser::new(tokens);
        let err = parser.ast().unwrap_err();
-        // TODO: Better errors when program cannot tokenize.
-        // https://github.com/KittyCAD/modeling-app/issues/696
-        assert!(err.to_string().contains("found list of unknown tokens"));
+        assert_eq!(
+            err.to_string(),
+            r#"lexical: KclErrorDetails { source_ranges: [SourceRange([1, 2])], message: "found unknown token '!'" }"#
+        );
    }

    #[test]
@ -2272,11 +2262,9 @@ z(-[["#,
        let parser = crate::parser::Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
-        // TODO: Better errors when program cannot tokenize.
-        // https://github.com/KittyCAD/modeling-app/issues/696
        assert_eq!(
            result.err().unwrap().to_string(),
-            r##"lexical: KclErrorDetails { source_ranges: [SourceRange([6, 7])], message: "found list of unknown tokens \"#\"" }"##
+            r#"lexical: KclErrorDetails { source_ranges: [SourceRange([6, 7])], message: "found unknown token '#'" }"#
        );
    }

@ -2286,11 +2274,9 @@ z(-[["#,
        let parser = crate::parser::Parser::new(tokens);
        let result = parser.ast();
        assert!(result.is_err());
-        // TODO: Better errors when program cannot tokenize.
-        // https://github.com/KittyCAD/modeling-app/issues/696
        assert_eq!(
            result.err().unwrap().to_string(),
-            r##"lexical: KclErrorDetails { source_ranges: [SourceRange([25, 26]), SourceRange([26, 27])], message: "found list of unknown tokens \"# #\"" }"##
+            r#"lexical: KclErrorDetails { source_ranges: [SourceRange([25, 26]), SourceRange([26, 27])], message: "found unknown tokens [#, #]" }"#
        );
    }

@ -2576,6 +2562,22 @@ thing(false)
        );
    }

+    #[test]
+    fn random_words_fail() {
+        let test_program = r#"const part001 = startSketchOn('-XZ')
+    |> startProfileAt([8.53, 11.8], %)
+    asdasd asdasd
+    |> line([11.12, -14.82], %)
+    |> line([-13.27, -6.98], %)
+    |> line([-5.09, 12.33], %)
+    asdasd
+"#;
+        let tokens = crate::token::lexer(test_program);
+        let parser = crate::parser::Parser::new(tokens);
+        let result = parser.ast();
+        let _e = result.unwrap_err();
+    }
+
    #[test]
    fn test_member_expression_sketch_group() {
        let some_program_string = r#"fn cube = (pos, scale) => {
@ -2798,4 +2800,5 @@ mod snapshot_tests {
    snapshot_test!(aq, "log(5, \"hello\", aIdentifier)");
    snapshot_test!(ar, r#"5 + "a""#);
    snapshot_test!(at, "line([0, l], %)");
+    snapshot_test!(au, include_str!("../../../tests/executor/inputs/cylinder.kcl"));
 }
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__a.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__a.snap
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ab.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ab.snap
@ -74,942 +74,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ad.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ad.snap
@ -74,10 +74,7 @@ expression: actual
          "name": "firstPrimeNumber"
        },
        "arguments": [],
-        "optional": false,
-        "function": {
-          "type": "InMemory"
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ae.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ae.snap
@ -88,10 +88,7 @@ expression: actual
            "name": "false"
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "InMemory"
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__af.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__af.snap
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ag.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ag.snap
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ah.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ah.snap
@ -42,503 +42,7 @@ expression: actual
                "name": "p"
              }
            ],
-            "optional": false,
-            "function": {
-              "type": "StdLib",
-              "func": {
-                "name": "startSketchAt",
-                "summary": "Start a sketch at a given point on the 'XY' plane.",
-                "description": "",
-                "tags": [],
-                "args": [
-                  {
-                    "name": "data",
-                    "type": "LineData",
-                    "schema": {
-                      "description": "Data to draw a line.",
-                      "anyOf": [
-                        {
-                          "description": "A point with a tag.",
-                          "type": "object",
-                          "required": [
-                            "tag",
-                            "to"
-                          ],
-                          "properties": {
-                            "tag": {
-                              "description": "The tag.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        {
-                          "description": "A point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      ]
-                    },
-                    "required": true
-                  }
-                ],
-                "returnValue": {
-                  "name": "",
-                  "type": "SketchGroup",
-                  "schema": {
-                    "description": "A sketch group is a collection of paths.",
-                    "type": "object",
-                    "required": [
-                      "__meta",
-                      "id",
-                      "position",
-                      "rotation",
-                      "start",
-                      "value"
-                    ],
-                    "properties": {
-                      "__meta": {
-                        "description": "Metadata.",
-                        "type": "array",
-                        "items": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        }
-                      },
-                      "id": {
-                        "description": "The id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid"
-                      },
-                      "planeId": {
-                        "description": "The plane id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid",
-                        "nullable": true
-                      },
-                      "position": {
-                        "description": "The position of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 3,
-                        "minItems": 3
-                      },
-                      "rotation": {
-                        "description": "The rotation of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 4,
-                        "minItems": 4
-                      },
-                      "start": {
-                        "description": "The starting path.",
-                        "type": "object",
-                        "required": [
-                          "__geoMeta",
-                          "from",
-                          "name",
-                          "to"
-                        ],
-                        "properties": {
-                          "__geoMeta": {
-                            "description": "Metadata.",
-                            "type": "object",
-                            "required": [
-                              "id",
-                              "sourceRange"
-                            ],
-                            "properties": {
-                              "id": {
-                                "description": "The id of the geometry.",
-                                "type": "string",
-                                "format": "uuid"
-                              },
-                              "sourceRange": {
-                                "description": "The source range.",
-                                "type": "array",
-                                "items": {
-                                  "type": "integer",
-                                  "format": "uint",
-                                  "minimum": 0.0
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              }
-                            }
-                          },
-                          "from": {
-                            "description": "The from point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          },
-                          "name": {
-                            "description": "The name of the path.",
-                            "type": "string"
-                          },
-                          "to": {
-                            "description": "The to point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "value": {
-                        "description": "The paths in the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "description": "A path.",
-                          "oneOf": [
-                            {
-                              "description": "A path that goes to a point.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "toPoint"
-                                  ]
-                                }
-                              }
-                            },
-                            {
-                              "description": "A path that is horizontal.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type",
-                                "x"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "horizontal"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double"
-                                }
-                              }
-                            },
-                            {
-                              "description": "An angled line to.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "angledLineTo"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                },
-                                "y": {
-                                  "description": "The y coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                }
-                              }
-                            },
-                            {
-                              "description": "A base path.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "base"
-                                  ]
-                                }
-                              }
-                            }
-                          ]
-                        }
-                      }
-                    }
-                  },
-                  "required": true
-                },
-                "unpublished": false,
-                "deprecated": false
-              }
-            }
+            "optional": false
          }
        }
      ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ai.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ai.snap
@ -49,10 +49,7 @@ expression: actual
                    "raw": "1"
                  }
                ],
-                "optional": false,
-                "function": {
-                  "type": "InMemory"
-                }
+                "optional": false
              },
              {
                "type": "CallExpression",
@ -75,10 +72,7 @@ expression: actual
                    "raw": "2"
                  }
                ],
-                "optional": false,
-                "function": {
-                  "type": "InMemory"
-                }
+                "optional": false
              }
            ],
            "nonCodeMeta": {
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__aj.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__aj.snap
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ak.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ak.snap
@ -67,942 +67,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__al.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__al.snap
@ -102,942 +102,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__am.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__am.snap
@ -67,942 +67,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__an.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__an.snap
@ -102,942 +102,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ao.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ao.snap
@ -102,942 +102,7 @@ expression: actual
            ]
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "lineTo",
-            "summary": "Draw a line to a point.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineToData",
-                "schema": {
-                  "description": "Data to draw a line to a point.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ap.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__ap.snap
@ -59,503 +59,7 @@ expression: actual
                ]
              }
            ],
-            "optional": false,
-            "function": {
-              "type": "StdLib",
-              "func": {
-                "name": "startSketchAt",
-                "summary": "Start a sketch at a given point on the 'XY' plane.",
-                "description": "",
-                "tags": [],
-                "args": [
-                  {
-                    "name": "data",
-                    "type": "LineData",
-                    "schema": {
-                      "description": "Data to draw a line.",
-                      "anyOf": [
-                        {
-                          "description": "A point with a tag.",
-                          "type": "object",
-                          "required": [
-                            "tag",
-                            "to"
-                          ],
-                          "properties": {
-                            "tag": {
-                              "description": "The tag.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        {
-                          "description": "A point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      ]
-                    },
-                    "required": true
-                  }
-                ],
-                "returnValue": {
-                  "name": "",
-                  "type": "SketchGroup",
-                  "schema": {
-                    "description": "A sketch group is a collection of paths.",
-                    "type": "object",
-                    "required": [
-                      "__meta",
-                      "id",
-                      "position",
-                      "rotation",
-                      "start",
-                      "value"
-                    ],
-                    "properties": {
-                      "__meta": {
-                        "description": "Metadata.",
-                        "type": "array",
-                        "items": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        }
-                      },
-                      "id": {
-                        "description": "The id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid"
-                      },
-                      "planeId": {
-                        "description": "The plane id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid",
-                        "nullable": true
-                      },
-                      "position": {
-                        "description": "The position of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 3,
-                        "minItems": 3
-                      },
-                      "rotation": {
-                        "description": "The rotation of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 4,
-                        "minItems": 4
-                      },
-                      "start": {
-                        "description": "The starting path.",
-                        "type": "object",
-                        "required": [
-                          "__geoMeta",
-                          "from",
-                          "name",
-                          "to"
-                        ],
-                        "properties": {
-                          "__geoMeta": {
-                            "description": "Metadata.",
-                            "type": "object",
-                            "required": [
-                              "id",
-                              "sourceRange"
-                            ],
-                            "properties": {
-                              "id": {
-                                "description": "The id of the geometry.",
-                                "type": "string",
-                                "format": "uuid"
-                              },
-                              "sourceRange": {
-                                "description": "The source range.",
-                                "type": "array",
-                                "items": {
-                                  "type": "integer",
-                                  "format": "uint",
-                                  "minimum": 0.0
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              }
-                            }
-                          },
-                          "from": {
-                            "description": "The from point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          },
-                          "name": {
-                            "description": "The name of the path.",
-                            "type": "string"
-                          },
-                          "to": {
-                            "description": "The to point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "value": {
-                        "description": "The paths in the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "description": "A path.",
-                          "oneOf": [
-                            {
-                              "description": "A path that goes to a point.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "toPoint"
-                                  ]
-                                }
-                              }
-                            },
-                            {
-                              "description": "A path that is horizontal.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type",
-                                "x"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "horizontal"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double"
-                                }
-                              }
-                            },
-                            {
-                              "description": "An angled line to.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "angledLineTo"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                },
-                                "y": {
-                                  "description": "The y coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                }
-                              }
-                            },
-                            {
-                              "description": "A base path.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "base"
-                                  ]
-                                }
-                              }
-                            }
-                          ]
-                        }
-                      }
-                    }
-                  },
-                  "required": true
-                },
-                "unpublished": false,
-                "deprecated": false
-              }
-            }
+            "optional": false
          }
        }
      ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__aq.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__aq.snap
@ -47,47 +47,7 @@ expression: actual
            "name": "aIdentifier"
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "log",
-            "summary": "Computes the logarithm of the number with respect to an arbitrary base.",
-            "description": "The result might not be correctly rounded owing to implementation details; `log2()` can produce more accurate results for base 2, and `log10()` can produce more accurate results for base 10.",
-            "tags": [],
-            "args": [
-              {
-                "name": "num",
-                "type": "number",
-                "schema": {
-                  "type": "number",
-                  "format": "double"
-                },
-                "required": true
-              },
-              {
-                "name": "base",
-                "type": "number",
-                "schema": {
-                  "type": "number",
-                  "format": "double"
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "number",
-              "schema": {
-                "type": "number",
-                "format": "double"
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__at.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__at.snap
@ -53,942 +53,7 @@ expression: actual
            "end": 14
          }
        ],
-        "optional": false,
-        "function": {
-          "type": "StdLib",
-          "func": {
-            "name": "line",
-            "summary": "Draw a line.",
-            "description": "",
-            "tags": [],
-            "args": [
-              {
-                "name": "data",
-                "type": "LineData",
-                "schema": {
-                  "description": "Data to draw a line.",
-                  "anyOf": [
-                    {
-                      "description": "A point with a tag.",
-                      "type": "object",
-                      "required": [
-                        "tag",
-                        "to"
-                      ],
-                      "properties": {
-                        "tag": {
-                          "description": "The tag.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    {
-                      "description": "A point.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 2,
-                      "minItems": 2
-                    }
-                  ]
-                },
-                "required": true
-              },
-              {
-                "name": "sketch_group",
-                "type": "SketchGroup",
-                "schema": {
-                  "description": "A sketch group is a collection of paths.",
-                  "type": "object",
-                  "required": [
-                    "__meta",
-                    "id",
-                    "position",
-                    "rotation",
-                    "start",
-                    "value"
-                  ],
-                  "properties": {
-                    "__meta": {
-                      "description": "Metadata.",
-                      "type": "array",
-                      "items": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      }
-                    },
-                    "id": {
-                      "description": "The id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid"
-                    },
-                    "planeId": {
-                      "description": "The plane id of the sketch group.",
-                      "type": "string",
-                      "format": "uuid",
-                      "nullable": true
-                    },
-                    "position": {
-                      "description": "The position of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 3,
-                      "minItems": 3
-                    },
-                    "rotation": {
-                      "description": "The rotation of the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      },
-                      "maxItems": 4,
-                      "minItems": 4
-                    },
-                    "start": {
-                      "description": "The starting path.",
-                      "type": "object",
-                      "required": [
-                        "__geoMeta",
-                        "from",
-                        "name",
-                        "to"
-                      ],
-                      "properties": {
-                        "__geoMeta": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "id",
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "id": {
-                              "description": "The id of the geometry.",
-                              "type": "string",
-                              "format": "uuid"
-                            },
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        "from": {
-                          "description": "The from point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        },
-                        "name": {
-                          "description": "The name of the path.",
-                          "type": "string"
-                        },
-                        "to": {
-                          "description": "The to point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    },
-                    "value": {
-                      "description": "The paths in the sketch group.",
-                      "type": "array",
-                      "items": {
-                        "description": "A path.",
-                        "oneOf": [
-                          {
-                            "description": "A path that goes to a point.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "toPoint"
-                                ]
-                              }
-                            }
-                          },
-                          {
-                            "description": "A path that is horizontal.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type",
-                              "x"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "horizontal"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double"
-                              }
-                            }
-                          },
-                          {
-                            "description": "An angled line to.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "angledLineTo"
-                                ]
-                              },
-                              "x": {
-                                "description": "The x coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              },
-                              "y": {
-                                "description": "The y coordinate.",
-                                "type": "number",
-                                "format": "double",
-                                "nullable": true
-                              }
-                            }
-                          },
-                          {
-                            "description": "A base path.",
-                            "type": "object",
-                            "required": [
-                              "__geoMeta",
-                              "from",
-                              "name",
-                              "to",
-                              "type"
-                            ],
-                            "properties": {
-                              "__geoMeta": {
-                                "description": "Metadata.",
-                                "type": "object",
-                                "required": [
-                                  "id",
-                                  "sourceRange"
-                                ],
-                                "properties": {
-                                  "id": {
-                                    "description": "The id of the geometry.",
-                                    "type": "string",
-                                    "format": "uuid"
-                                  },
-                                  "sourceRange": {
-                                    "description": "The source range.",
-                                    "type": "array",
-                                    "items": {
-                                      "type": "integer",
-                                      "format": "uint",
-                                      "minimum": 0.0
-                                    },
-                                    "maxItems": 2,
-                                    "minItems": 2
-                                  }
-                                }
-                              },
-                              "from": {
-                                "description": "The from point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "name": {
-                                "description": "The name of the path.",
-                                "type": "string"
-                              },
-                              "to": {
-                                "description": "The to point.",
-                                "type": "array",
-                                "items": {
-                                  "type": "number",
-                                  "format": "double"
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              },
-                              "type": {
-                                "type": "string",
-                                "enum": [
-                                  "base"
-                                ]
-                              }
-                            }
-                          }
-                        ]
-                      }
-                    }
-                  }
-                },
-                "required": true
-              }
-            ],
-            "returnValue": {
-              "name": "",
-              "type": "SketchGroup",
-              "schema": {
-                "description": "A sketch group is a collection of paths.",
-                "type": "object",
-                "required": [
-                  "__meta",
-                  "id",
-                  "position",
-                  "rotation",
-                  "start",
-                  "value"
-                ],
-                "properties": {
-                  "__meta": {
-                    "description": "Metadata.",
-                    "type": "array",
-                    "items": {
-                      "description": "Metadata.",
-                      "type": "object",
-                      "required": [
-                        "sourceRange"
-                      ],
-                      "properties": {
-                        "sourceRange": {
-                          "description": "The source range.",
-                          "type": "array",
-                          "items": {
-                            "type": "integer",
-                            "format": "uint",
-                            "minimum": 0.0
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      }
-                    }
-                  },
-                  "id": {
-                    "description": "The id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid"
-                  },
-                  "planeId": {
-                    "description": "The plane id of the sketch group.",
-                    "type": "string",
-                    "format": "uuid",
-                    "nullable": true
-                  },
-                  "position": {
-                    "description": "The position of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 3,
-                    "minItems": 3
-                  },
-                  "rotation": {
-                    "description": "The rotation of the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "type": "number",
-                      "format": "double"
-                    },
-                    "maxItems": 4,
-                    "minItems": 4
-                  },
-                  "start": {
-                    "description": "The starting path.",
-                    "type": "object",
-                    "required": [
-                      "__geoMeta",
-                      "from",
-                      "name",
-                      "to"
-                    ],
-                    "properties": {
-                      "__geoMeta": {
-                        "description": "Metadata.",
-                        "type": "object",
-                        "required": [
-                          "id",
-                          "sourceRange"
-                        ],
-                        "properties": {
-                          "id": {
-                            "description": "The id of the geometry.",
-                            "type": "string",
-                            "format": "uuid"
-                          },
-                          "sourceRange": {
-                            "description": "The source range.",
-                            "type": "array",
-                            "items": {
-                              "type": "integer",
-                              "format": "uint",
-                              "minimum": 0.0
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "from": {
-                        "description": "The from point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      },
-                      "name": {
-                        "description": "The name of the path.",
-                        "type": "string"
-                      },
-                      "to": {
-                        "description": "The to point.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 2,
-                        "minItems": 2
-                      }
-                    }
-                  },
-                  "value": {
-                    "description": "The paths in the sketch group.",
-                    "type": "array",
-                    "items": {
-                      "description": "A path.",
-                      "oneOf": [
-                        {
-                          "description": "A path that goes to a point.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "toPoint"
-                              ]
-                            }
-                          }
-                        },
-                        {
-                          "description": "A path that is horizontal.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type",
-                            "x"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "horizontal"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double"
-                            }
-                          }
-                        },
-                        {
-                          "description": "An angled line to.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "angledLineTo"
-                              ]
-                            },
-                            "x": {
-                              "description": "The x coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            },
-                            "y": {
-                              "description": "The y coordinate.",
-                              "type": "number",
-                              "format": "double",
-                              "nullable": true
-                            }
-                          }
-                        },
-                        {
-                          "description": "A base path.",
-                          "type": "object",
-                          "required": [
-                            "__geoMeta",
-                            "from",
-                            "name",
-                            "to",
-                            "type"
-                          ],
-                          "properties": {
-                            "__geoMeta": {
-                              "description": "Metadata.",
-                              "type": "object",
-                              "required": [
-                                "id",
-                                "sourceRange"
-                              ],
-                              "properties": {
-                                "id": {
-                                  "description": "The id of the geometry.",
-                                  "type": "string",
-                                  "format": "uuid"
-                                },
-                                "sourceRange": {
-                                  "description": "The source range.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "integer",
-                                    "format": "uint",
-                                    "minimum": 0.0
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                }
-                              }
-                            },
-                            "from": {
-                              "description": "The from point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "name": {
-                              "description": "The name of the path.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            },
-                            "type": {
-                              "type": "string",
-                              "enum": [
-                                "base"
-                              ]
-                            }
-                          }
-                        }
-                      ]
-                    }
-                  }
-                }
-              },
-              "required": true
-            },
-            "unpublished": false,
-            "deprecated": false
-          }
-        }
+        "optional": false
      }
    }
  ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__au.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__au.snap
@ -0,0 +1,158 @@
+---
+source: kcl/src/parser/parser_impl.rs
+expression: actual
+---
+{
+  "start": 0,
+  "end": 90,
+  "body": [
+    {
+      "type": "VariableDeclaration",
+      "type": "VariableDeclaration",
+      "start": 0,
+      "end": 74,
+      "declarations": [
+        {
+          "type": "VariableDeclarator",
+          "start": 6,
+          "end": 74,
+          "id": {
+            "type": "Identifier",
+            "start": 6,
+            "end": 14,
+            "name": "cylinder"
+          },
+          "init": {
+            "type": "PipeExpression",
+            "type": "PipeExpression",
+            "start": 17,
+            "end": 74,
+            "body": [
+              {
+                "type": "CallExpression",
+                "type": "CallExpression",
+                "start": 17,
+                "end": 56,
+                "callee": {
+                  "type": "Identifier",
+                  "start": 17,
+                  "end": 39,
+                  "name": "unstable_stdlib_circle"
+                },
+                "arguments": [
+                  {
+                    "type": "Literal",
+                    "type": "Literal",
+                    "start": 40,
+                    "end": 44,
+                    "value": "XY",
+                    "raw": "'XY'"
+                  },
+                  {
+                    "type": "ArrayExpression",
+                    "type": "ArrayExpression",
+                    "start": 46,
+                    "end": 51,
+                    "elements": [
+                      {
+                        "type": "Literal",
+                        "type": "Literal",
+                        "start": 47,
+                        "end": 48,
+                        "value": 0,
+                        "raw": "0"
+                      },
+                      {
+                        "type": "Literal",
+                        "type": "Literal",
+                        "start": 49,
+                        "end": 50,
+                        "value": 0,
+                        "raw": "0"
+                      }
+                    ]
+                  },
+                  {
+                    "type": "Literal",
+                    "type": "Literal",
+                    "start": 53,
+                    "end": 55,
+                    "value": 22,
+                    "raw": "22"
+                  }
+                ],
+                "optional": false
+              },
+              {
+                "type": "CallExpression",
+                "type": "CallExpression",
+                "start": 60,
+                "end": 74,
+                "callee": {
+                  "type": "Identifier",
+                  "start": 60,
+                  "end": 67,
+                  "name": "extrude"
+                },
+                "arguments": [
+                  {
+                    "type": "Literal",
+                    "type": "Literal",
+                    "start": 68,
+                    "end": 70,
+                    "value": 14,
+                    "raw": "14"
+                  },
+                  {
+                    "type": "PipeSubstitution",
+                    "type": "PipeSubstitution",
+                    "start": 72,
+                    "end": 73
+                  }
+                ],
+                "optional": false
+              }
+            ],
+            "nonCodeMeta": {
+              "nonCodeNodes": {},
+              "start": []
+            }
+          }
+        }
+      ],
+      "kind": "const"
+    },
+    {
+      "type": "ExpressionStatement",
+      "type": "ExpressionStatement",
+      "start": 75,
+      "end": 89,
+      "expression": {
+        "type": "CallExpression",
+        "type": "CallExpression",
+        "start": 75,
+        "end": 89,
+        "callee": {
+          "type": "Identifier",
+          "start": 75,
+          "end": 79,
+          "name": "show"
+        },
+        "arguments": [
+          {
+            "type": "Identifier",
+            "type": "Identifier",
+            "start": 80,
+            "end": 88,
+            "name": "cylinder"
+          }
+        ],
+        "optional": false
+      }
+    }
+  ],
+  "nonCodeMeta": {
+    "nonCodeNodes": {},
+    "start": []
+  }
+}
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__b.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__b.snap
@ -77,85 +77,11 @@ expression: actual
                      "raw": "4"
                    }
                  ],
-                  "optional": false,
-                  "function": {
-                    "type": "StdLib",
-                    "func": {
-                      "name": "legLen",
-                      "summary": "Returns the length of the given leg.",
-                      "description": "",
-                      "tags": [],
-                      "args": [
-                        {
-                          "name": "hypotenuse",
-                          "type": "number",
-                          "schema": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "required": true
-                        },
-                        {
-                          "name": "leg",
-                          "type": "number",
-                          "schema": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "required": true
-                        }
-                      ],
-                      "returnValue": {
-                        "name": "",
-                        "type": "number",
-                        "schema": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "required": true
-                      },
-                      "unpublished": false,
-                      "deprecated": false
-                    }
-                  }
+                  "optional": false
                }
              }
            ],
-            "optional": false,
-            "function": {
-              "type": "StdLib",
-              "func": {
-                "name": "min",
-                "summary": "Computes the minimum of the given arguments.",
-                "description": "",
-                "tags": [],
-                "args": [
-                  {
-                    "name": "args",
-                    "type": "[number]",
-                    "schema": {
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      }
-                    },
-                    "required": true
-                  }
-                ],
-                "returnValue": {
-                  "name": "",
-                  "type": "number",
-                  "schema": {
-                    "type": "number",
-                    "format": "double"
-                  },
-                  "required": true
-                },
-                "unpublished": false,
-                "deprecated": false
-              }
-            }
+            "optional": false
          }
        }
      ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__c.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__c.snap
@ -69,47 +69,7 @@ expression: actual
                      "raw": "4"
                    }
                  ],
-                  "optional": false,
-                  "function": {
-                    "type": "StdLib",
-                    "func": {
-                      "name": "legLen",
-                      "summary": "Returns the length of the given leg.",
-                      "description": "",
-                      "tags": [],
-                      "args": [
-                        {
-                          "name": "hypotenuse",
-                          "type": "number",
-                          "schema": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "required": true
-                        },
-                        {
-                          "name": "leg",
-                          "type": "number",
-                          "schema": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "required": true
-                        }
-                      ],
-                      "returnValue": {
-                        "name": "",
-                        "type": "number",
-                        "schema": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "required": true
-                      },
-                      "unpublished": false,
-                      "deprecated": false
-                    }
-                  }
+                  "optional": false
                }
              },
              {
@ -121,41 +81,7 @@ expression: actual
                "raw": "5"
              }
            ],
-            "optional": false,
-            "function": {
-              "type": "StdLib",
-              "func": {
-                "name": "min",
-                "summary": "Computes the minimum of the given arguments.",
-                "description": "",
-                "tags": [],
-                "args": [
-                  {
-                    "name": "args",
-                    "type": "[number]",
-                    "schema": {
-                      "type": "array",
-                      "items": {
-                        "type": "number",
-                        "format": "double"
-                      }
-                    },
-                    "required": true
-                  }
-                ],
-                "returnValue": {
-                  "name": "",
-                  "type": "number",
-                  "schema": {
-                    "type": "number",
-                    "format": "double"
-                  },
-                  "required": true
-                },
-                "unpublished": false,
-                "deprecated": false
-              }
-            }
+            "optional": false
          }
        }
      ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__d.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__d.snap
@ -78,10 +78,7 @@ expression: actual
                    "end": 35
                  }
                ],
-                "optional": false,
-                "function": {
-                  "type": "InMemory"
-                }
+                "optional": false
              }
            ],
            "nonCodeMeta": {
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__y.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__y.snap
@ -42,503 +42,7 @@ expression: actual
                "name": "pos"
              }
            ],
-            "optional": false,
-            "function": {
-              "type": "StdLib",
-              "func": {
-                "name": "startSketchAt",
-                "summary": "Start a sketch at a given point on the 'XY' plane.",
-                "description": "",
-                "tags": [],
-                "args": [
-                  {
-                    "name": "data",
-                    "type": "LineData",
-                    "schema": {
-                      "description": "Data to draw a line.",
-                      "anyOf": [
-                        {
-                          "description": "A point with a tag.",
-                          "type": "object",
-                          "required": [
-                            "tag",
-                            "to"
-                          ],
-                          "properties": {
-                            "tag": {
-                              "description": "The tag.",
-                              "type": "string"
-                            },
-                            "to": {
-                              "description": "The to point.",
-                              "type": "array",
-                              "items": {
-                                "type": "number",
-                                "format": "double"
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        },
-                        {
-                          "description": "A point.",
-                          "type": "array",
-                          "items": {
-                            "type": "number",
-                            "format": "double"
-                          },
-                          "maxItems": 2,
-                          "minItems": 2
-                        }
-                      ]
-                    },
-                    "required": true
-                  }
-                ],
-                "returnValue": {
-                  "name": "",
-                  "type": "SketchGroup",
-                  "schema": {
-                    "description": "A sketch group is a collection of paths.",
-                    "type": "object",
-                    "required": [
-                      "__meta",
-                      "id",
-                      "position",
-                      "rotation",
-                      "start",
-                      "value"
-                    ],
-                    "properties": {
-                      "__meta": {
-                        "description": "Metadata.",
-                        "type": "array",
-                        "items": {
-                          "description": "Metadata.",
-                          "type": "object",
-                          "required": [
-                            "sourceRange"
-                          ],
-                          "properties": {
-                            "sourceRange": {
-                              "description": "The source range.",
-                              "type": "array",
-                              "items": {
-                                "type": "integer",
-                                "format": "uint",
-                                "minimum": 0.0
-                              },
-                              "maxItems": 2,
-                              "minItems": 2
-                            }
-                          }
-                        }
-                      },
-                      "id": {
-                        "description": "The id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid"
-                      },
-                      "planeId": {
-                        "description": "The plane id of the sketch group.",
-                        "type": "string",
-                        "format": "uuid",
-                        "nullable": true
-                      },
-                      "position": {
-                        "description": "The position of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 3,
-                        "minItems": 3
-                      },
-                      "rotation": {
-                        "description": "The rotation of the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "type": "number",
-                          "format": "double"
-                        },
-                        "maxItems": 4,
-                        "minItems": 4
-                      },
-                      "start": {
-                        "description": "The starting path.",
-                        "type": "object",
-                        "required": [
-                          "__geoMeta",
-                          "from",
-                          "name",
-                          "to"
-                        ],
-                        "properties": {
-                          "__geoMeta": {
-                            "description": "Metadata.",
-                            "type": "object",
-                            "required": [
-                              "id",
-                              "sourceRange"
-                            ],
-                            "properties": {
-                              "id": {
-                                "description": "The id of the geometry.",
-                                "type": "string",
-                                "format": "uuid"
-                              },
-                              "sourceRange": {
-                                "description": "The source range.",
-                                "type": "array",
-                                "items": {
-                                  "type": "integer",
-                                  "format": "uint",
-                                  "minimum": 0.0
-                                },
-                                "maxItems": 2,
-                                "minItems": 2
-                              }
-                            }
-                          },
-                          "from": {
-                            "description": "The from point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          },
-                          "name": {
-                            "description": "The name of the path.",
-                            "type": "string"
-                          },
-                          "to": {
-                            "description": "The to point.",
-                            "type": "array",
-                            "items": {
-                              "type": "number",
-                              "format": "double"
-                            },
-                            "maxItems": 2,
-                            "minItems": 2
-                          }
-                        }
-                      },
-                      "value": {
-                        "description": "The paths in the sketch group.",
-                        "type": "array",
-                        "items": {
-                          "description": "A path.",
-                          "oneOf": [
-                            {
-                              "description": "A path that goes to a point.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "toPoint"
-                                  ]
-                                }
-                              }
-                            },
-                            {
-                              "description": "A path that is horizontal.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type",
-                                "x"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "horizontal"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double"
-                                }
-                              }
-                            },
-                            {
-                              "description": "An angled line to.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "angledLineTo"
-                                  ]
-                                },
-                                "x": {
-                                  "description": "The x coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                },
-                                "y": {
-                                  "description": "The y coordinate.",
-                                  "type": "number",
-                                  "format": "double",
-                                  "nullable": true
-                                }
-                              }
-                            },
-                            {
-                              "description": "A base path.",
-                              "type": "object",
-                              "required": [
-                                "__geoMeta",
-                                "from",
-                                "name",
-                                "to",
-                                "type"
-                              ],
-                              "properties": {
-                                "__geoMeta": {
-                                  "description": "Metadata.",
-                                  "type": "object",
-                                  "required": [
-                                    "id",
-                                    "sourceRange"
-                                  ],
-                                  "properties": {
-                                    "id": {
-                                      "description": "The id of the geometry.",
-                                      "type": "string",
-                                      "format": "uuid"
-                                    },
-                                    "sourceRange": {
-                                      "description": "The source range.",
-                                      "type": "array",
-                                      "items": {
-                                        "type": "integer",
-                                        "format": "uint",
-                                        "minimum": 0.0
-                                      },
-                                      "maxItems": 2,
-                                      "minItems": 2
-                                    }
-                                  }
-                                },
-                                "from": {
-                                  "description": "The from point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "name": {
-                                  "description": "The name of the path.",
-                                  "type": "string"
-                                },
-                                "to": {
-                                  "description": "The to point.",
-                                  "type": "array",
-                                  "items": {
-                                    "type": "number",
-                                    "format": "double"
-                                  },
-                                  "maxItems": 2,
-                                  "minItems": 2
-                                },
-                                "type": {
-                                  "type": "string",
-                                  "enum": [
-                                    "base"
-                                  ]
-                                }
-                              }
-                            }
-                          ]
-                        }
-                      }
-                    }
-                  },
-                  "required": true
-                },
-                "unpublished": false,
-                "deprecated": false
-              }
-            }
+            "optional": false
          }
        }
      ],
--- a/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__z.snap
+++ b/src/wasm-lib/kcl/src/parser/snapshots/kcl_libparserparser_impl__snapshot_tests__z.snap
--- a/src/wasm-lib/kcl/src/std/kcl_stdlib.rs
+++ b/src/wasm-lib/kcl/src/std/kcl_stdlib.rs
@ -0,0 +1,82 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    ast::types::{BodyItem, FunctionExpression, Program, Value},
+    docs::{StdLibFn, StdLibFnData},
+    token::lexer,
+};
+
+pub trait KclStdLibFn: StdLibFn {
+    fn kcl_clone_box(&self) -> Box<dyn KclStdLibFn>;
+    fn function(&self) -> &FunctionExpression;
+    fn program(&self) -> &Program;
+}
+
+impl ts_rs::TS for dyn KclStdLibFn {
+    const EXPORT_TO: Option<&'static str> = Some("bindings/StdLibFnData");
+
+    fn name() -> String {
+        "StdLibFnData".to_string()
+    }
+
+    fn dependencies() -> Vec<ts_rs::Dependency>
+    where
+        Self: 'static,
+    {
+        StdLibFnData::dependencies()
+    }
+
+    fn transparent() -> bool {
+        StdLibFnData::transparent()
+    }
+}
+
+impl Clone for Box<dyn KclStdLibFn> {
+    fn clone(&self) -> Box<dyn KclStdLibFn> {
+        self.kcl_clone_box()
+    }
+}
+
+impl JsonSchema for dyn KclStdLibFn {
+    fn schema_name() -> String {
+        "KclStdLibFn".to_string()
+    }
+
+    fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+        gen.subschema_for::<StdLibFnData>()
+    }
+}
+
+impl<'de> Deserialize<'de> for Box<dyn KclStdLibFn> {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let data = StdLibFnData::deserialize(deserializer)?;
+        let stdlib = crate::std::StdLib::new();
+        let stdlib_fn = stdlib
+            .get_kcl(&data.name)
+            .ok_or_else(|| serde::de::Error::custom(format!("StdLibFn {} not found", data.name)))?;
+        Ok(stdlib_fn)
+    }
+}
+
+impl Serialize for Box<dyn KclStdLibFn> {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        self.to_json().unwrap().serialize(serializer)
+    }
+}
+
+/// Parse a KCL program. Expect it to have a single body item, which is a function.
+/// Return the program and its single function.
+/// Return None if those expectations aren't met.
+pub fn extract_function(source: &str) -> Option<(Program, Box<FunctionExpression>)> {
+    let tokens = lexer(source);
+    let src = crate::parser::Parser::new(tokens).ast().ok()?;
+    assert_eq!(src.body.len(), 1);
+    let BodyItem::ExpressionStatement(expr) = src.body.last()? else {
+        panic!("expected expression statement");
+    };
+    let Value::FunctionExpression(function) = expr.expression.clone() else {
+        panic!("expected function expr");
+    };
+    Some((src, function))
+}
--- a/src/wasm-lib/kcl/src/std/mod.rs
+++ b/src/wasm-lib/kcl/src/std/mod.rs
@ -1,8 +1,10 @@
 //! Functions implemented for language execution.

 pub mod extrude;
+pub mod kcl_stdlib;
 pub mod math;
 pub mod segment;
+pub mod shapes;
 pub mod sketch;
 pub mod utils;

@ -11,12 +13,15 @@ use std::collections::HashMap;
 use anyhow::Result;
 use derive_docs::stdlib;
 use kittycad::types::OkWebSocketResponseData;
+use lazy_static::lazy_static;
 use parse_display::{Display, FromStr};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};

+use self::kcl_stdlib::KclStdLibFn;
 use crate::{
    ast::types::parse_json_number_as_f64,
+    docs::StdLibFn,
    engine::EngineManager,
    errors::{KclError, KclErrorDetails},
    executor::{ExecutorContext, ExtrudeGroup, MemoryItem, Metadata, Plane, SketchGroup, SourceRange},
@ -25,81 +30,122 @@ use crate::{
 pub type StdFn = fn(Args) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<MemoryItem, KclError>>>>;
 pub type FnMap = HashMap<String, StdFn>;

+lazy_static! {
+    static ref CORE_FNS: Vec<Box<dyn StdLibFn>> = vec![
+        Box::new(Show),
+        Box::new(LegLen),
+        Box::new(LegAngX),
+        Box::new(LegAngY),
+        Box::new(crate::std::extrude::Extrude),
+        Box::new(crate::std::extrude::GetExtrudeWallTransform),
+        Box::new(crate::std::segment::SegEndX),
+        Box::new(crate::std::segment::SegEndY),
+        Box::new(crate::std::segment::LastSegX),
+        Box::new(crate::std::segment::LastSegY),
+        Box::new(crate::std::segment::SegLen),
+        Box::new(crate::std::segment::SegAng),
+        Box::new(crate::std::segment::AngleToMatchLengthX),
+        Box::new(crate::std::segment::AngleToMatchLengthY),
+        Box::new(crate::std::sketch::LineTo),
+        Box::new(crate::std::sketch::Line),
+        Box::new(crate::std::sketch::XLineTo),
+        Box::new(crate::std::sketch::XLine),
+        Box::new(crate::std::sketch::YLineTo),
+        Box::new(crate::std::sketch::YLine),
+        Box::new(crate::std::sketch::AngledLineToX),
+        Box::new(crate::std::sketch::AngledLineToY),
+        Box::new(crate::std::sketch::AngledLine),
+        Box::new(crate::std::sketch::AngledLineOfXLength),
+        Box::new(crate::std::sketch::AngledLineOfYLength),
+        Box::new(crate::std::sketch::AngledLineThatIntersects),
+        Box::new(crate::std::sketch::StartSketchAt),
+        Box::new(crate::std::sketch::StartSketchOn),
+        Box::new(crate::std::sketch::StartProfileAt),
+        Box::new(crate::std::sketch::Close),
+        Box::new(crate::std::sketch::Arc),
+        Box::new(crate::std::sketch::TangentialArc),
+        Box::new(crate::std::sketch::TangentialArcTo),
+        Box::new(crate::std::sketch::BezierCurve),
+        Box::new(crate::std::sketch::Hole),
+        Box::new(crate::std::math::Cos),
+        Box::new(crate::std::math::Sin),
+        Box::new(crate::std::math::Tan),
+        Box::new(crate::std::math::Acos),
+        Box::new(crate::std::math::Asin),
+        Box::new(crate::std::math::Atan),
+        Box::new(crate::std::math::Pi),
+        Box::new(crate::std::math::E),
+        Box::new(crate::std::math::Tau),
+        Box::new(crate::std::math::Sqrt),
+        Box::new(crate::std::math::Abs),
+        Box::new(crate::std::math::Floor),
+        Box::new(crate::std::math::Ceil),
+        Box::new(crate::std::math::Min),
+        Box::new(crate::std::math::Max),
+        Box::new(crate::std::math::Pow),
+        Box::new(crate::std::math::Log),
+        Box::new(crate::std::math::Log2),
+        Box::new(crate::std::math::Log10),
+        Box::new(crate::std::math::Ln),
+    ];
+}
+
+pub fn name_in_stdlib(name: &str) -> bool {
+    CORE_FNS.iter().any(|f| f.name() == name)
+}
+
 pub struct StdLib {
-    pub fns: HashMap<String, Box<(dyn crate::docs::StdLibFn)>>,
+    pub fns: HashMap<String, Box<dyn StdLibFn>>,
+    pub kcl_fns: HashMap<String, Box<dyn KclStdLibFn>>,
+}
+
+impl std::fmt::Debug for StdLib {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StdLib")
+            .field("fns.len()", &self.fns.len())
+            .field("kcl_fns.len()", &self.kcl_fns.len())
+            .finish()
+    }
 }

 impl StdLib {
    pub fn new() -> Self {
-        let internal_fns: Vec<Box<(dyn crate::docs::StdLibFn)>> = vec![
-            Box::new(Show),
-            Box::new(LegLen),
-            Box::new(LegAngX),
-            Box::new(LegAngY),
-            Box::new(crate::std::extrude::Extrude),
-            Box::new(crate::std::extrude::GetExtrudeWallTransform),
-            Box::new(crate::std::segment::SegEndX),
-            Box::new(crate::std::segment::SegEndY),
-            Box::new(crate::std::segment::LastSegX),
-            Box::new(crate::std::segment::LastSegY),
-            Box::new(crate::std::segment::SegLen),
-            Box::new(crate::std::segment::SegAng),
-            Box::new(crate::std::segment::AngleToMatchLengthX),
-            Box::new(crate::std::segment::AngleToMatchLengthY),
-            Box::new(crate::std::sketch::LineTo),
-            Box::new(crate::std::sketch::Line),
-            Box::new(crate::std::sketch::XLineTo),
-            Box::new(crate::std::sketch::XLine),
-            Box::new(crate::std::sketch::YLineTo),
-            Box::new(crate::std::sketch::YLine),
-            Box::new(crate::std::sketch::AngledLineToX),
-            Box::new(crate::std::sketch::AngledLineToY),
-            Box::new(crate::std::sketch::AngledLine),
-            Box::new(crate::std::sketch::AngledLineOfXLength),
-            Box::new(crate::std::sketch::AngledLineOfYLength),
-            Box::new(crate::std::sketch::AngledLineThatIntersects),
-            Box::new(crate::std::sketch::StartSketchAt),
-            Box::new(crate::std::sketch::StartSketchOn),
-            Box::new(crate::std::sketch::StartProfileAt),
-            Box::new(crate::std::sketch::Close),
-            Box::new(crate::std::sketch::Arc),
-            Box::new(crate::std::sketch::TangentialArc),
-            Box::new(crate::std::sketch::TangentialArcTo),
-            Box::new(crate::std::sketch::BezierCurve),
-            Box::new(crate::std::sketch::Hole),
-            Box::new(crate::std::math::Cos),
-            Box::new(crate::std::math::Sin),
-            Box::new(crate::std::math::Tan),
-            Box::new(crate::std::math::Acos),
-            Box::new(crate::std::math::Asin),
-            Box::new(crate::std::math::Atan),
-            Box::new(crate::std::math::Pi),
-            Box::new(crate::std::math::E),
-            Box::new(crate::std::math::Tau),
-            Box::new(crate::std::math::Sqrt),
-            Box::new(crate::std::math::Abs),
-            Box::new(crate::std::math::Floor),
-            Box::new(crate::std::math::Ceil),
-            Box::new(crate::std::math::Min),
-            Box::new(crate::std::math::Max),
-            Box::new(crate::std::math::Pow),
-            Box::new(crate::std::math::Log),
-            Box::new(crate::std::math::Log2),
-            Box::new(crate::std::math::Log10),
-            Box::new(crate::std::math::Ln),
-        ];
+        let fns = CORE_FNS
+            .clone()
+            .into_iter()
+            .map(|internal_fn| (internal_fn.name(), internal_fn))
+            .collect();

-        let mut fns = HashMap::new();
-        for internal_fn in &internal_fns {
-            fns.insert(internal_fn.name().to_string(), internal_fn.clone());
-        }
+        let kcl_internal_fns: [Box<dyn KclStdLibFn>; 1] = [Box::<shapes::Circle>::default()];
+        let kcl_fns = kcl_internal_fns
+            .into_iter()
+            .map(|internal_fn| (internal_fn.name(), internal_fn))
+            .collect();

-        Self { fns }
+        Self { fns, kcl_fns }
    }

-    pub fn get(&self, name: &str) -> Option<Box<dyn crate::docs::StdLibFn>> {
+    pub fn get(&self, name: &str) -> Option<Box<dyn StdLibFn>> {
        self.fns.get(name).cloned()
    }
+
+    pub fn get_kcl(&self, name: &str) -> Option<Box<dyn KclStdLibFn>> {
+        self.kcl_fns.get(name).cloned()
+    }
+
+    pub fn get_either(&self, name: &str) -> FunctionKind {
+        if let Some(f) = self.get(name) {
+            FunctionKind::Core(f)
+        } else if let Some(f) = self.get_kcl(name) {
+            FunctionKind::Std(f)
+        } else {
+            FunctionKind::UserDefined
+        }
+    }
+
+    pub fn contains_key(&self, key: &str) -> bool {
+        self.fns.contains_key(key) || self.kcl_fns.contains_key(key)
+    }
 }

 impl Default for StdLib {
@ -108,6 +154,12 @@ impl Default for StdLib {
    }
 }

+pub enum FunctionKind {
+    Core(Box<dyn StdLibFn>),
+    Std(Box<dyn KclStdLibFn>),
+    UserDefined,
+}
+
 #[derive(Debug, Clone)]
 pub struct Args {
    pub args: Vec<MemoryItem>,
--- a/src/wasm-lib/kcl/src/std/shapes.rs
+++ b/src/wasm-lib/kcl/src/std/shapes.rs
@ -0,0 +1,102 @@
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+use super::kcl_stdlib::KclStdLibFn;
+use crate::{
+    ast::types::{FunctionExpression, Program},
+    docs::StdLibFn,
+};
+
+pub const CIRCLE_FN: &str = r#"
+(plane, center, radius) => {
+  const sg = startSketchOn(plane)
+    |> startProfileAt([center[0] + radius, center[1]], %)
+    |> arc({
+       angle_end: 360,
+       angle_start: 0,
+       radius: radius
+     }, %)
+    |> close(%)
+  return sg
+}
+    "#;
+
+#[derive(Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]
+pub struct Circle {
+    function: FunctionExpression,
+    program: Program,
+}
+
+impl Default for Circle {
+    fn default() -> Self {
+        // TODO in https://github.com/KittyCAD/modeling-app/issues/1018
+        // Don't unwrap here, parse it at compile-time.
+        let (src, function) = super::kcl_stdlib::extract_function(CIRCLE_FN).unwrap();
+        Self {
+            function: *function,
+            program: src,
+        }
+    }
+}
+
+impl std::fmt::Debug for Circle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        "circle".fmt(f)
+    }
+}
+
+/// TODO: Parse the KCL in a macro and generate these
+impl StdLibFn for Circle {
+    fn name(&self) -> String {
+        "unstable_stdlib_circle".to_owned()
+    }
+
+    fn summary(&self) -> String {
+        "Sketch a circle on the given plane".to_owned()
+    }
+
+    fn description(&self) -> String {
+        String::new()
+    }
+
+    fn tags(&self) -> Vec<String> {
+        Vec::new()
+    }
+
+    fn args(&self) -> Vec<crate::docs::StdLibFnArg> {
+        Vec::new() // TODO
+    }
+
+    fn return_value(&self) -> Option<crate::docs::StdLibFnArg> {
+        None
+    }
+
+    fn unpublished(&self) -> bool {
+        true
+    }
+
+    fn deprecated(&self) -> bool {
+        false
+    }
+
+    fn std_lib_fn(&self) -> crate::std::StdFn {
+        todo!()
+    }
+
+    fn clone_box(&self) -> Box<dyn StdLibFn> {
+        Box::new(self.to_owned())
+    }
+}
+
+impl KclStdLibFn for Circle {
+    fn function(&self) -> &FunctionExpression {
+        &self.function
+    }
+    fn program(&self) -> &Program {
+        &self.program
+    }
+
+    fn kcl_clone_box(&self) -> Box<dyn KclStdLibFn> {
+        Box::new(self.clone())
+    }
+}
--- a/src/wasm-lib/src/lib.rs
+++ b/src/wasm-lib/src/lib.rs
@ -28,7 +28,11 @@ pub async fn execute_wasm(
    let engine = kcl_lib::engine::EngineConnection::new(manager)
        .await
        .map_err(|e| format!("{:?}", e))?;
-    let ctx = ExecutorContext { engine, planes };
+    let ctx = ExecutorContext {
+        engine,
+        planes,
+        stdlib: std::sync::Arc::new(kcl_lib::std::StdLib::new()),
+    };

    let memory = kcl_lib::executor::execute(program, &mut mem, kcl_lib::executor::BodyType::Root, &ctx)
        .await
--- a/src/wasm-lib/tests/executor/inputs/cylinder.kcl
+++ b/src/wasm-lib/tests/executor/inputs/cylinder.kcl
@ -0,0 +1,2 @@
+const cylinder = unstable_stdlib_circle('XY', [0,0], 22) |> extrude(14, %)
+show(cylinder)
--- a/src/wasm-lib/tests/executor/main.rs
+++ b/src/wasm-lib/tests/executor/main.rs
@ -1,5 +1,7 @@
+use std::sync::Arc;
+
 use anyhow::Result;
-use kcl_lib::engine::EngineManager;
+use kcl_lib::{engine::EngineManager, std::StdLib};

 /// Executes a kcl program and takes a snapshot of the result.
 /// This returns the bytes of the snapshot.
@ -38,7 +40,11 @@ async fn execute_and_snapshot(code: &str) -> Result<image::DynamicImage> {
    let mut mem: kcl_lib::executor::ProgramMemory = Default::default();
    let engine = kcl_lib::engine::EngineConnection::new(ws).await?;
    let planes = kcl_lib::executor::DefaultPlanes::new(&engine).await?;
-    let ctx = kcl_lib::executor::ExecutorContext { engine, planes };
+    let ctx = kcl_lib::executor::ExecutorContext {
+        engine,
+        planes,
+        stdlib: Arc::new(StdLib::default()),
+    };
    let _ = kcl_lib::executor::execute(program, &mut mem, kcl_lib::executor::BodyType::Root, &ctx).await?;

    // Send a snapshot request to the engine.
@ -222,6 +228,14 @@ async fn serial_test_execute_pipes_on_pipes() {
    twenty_twenty::assert_image("tests/executor/outputs/pipes_on_pipes.png", &result, 0.999);
 }

+#[tokio::test(flavor = "multi_thread")]
+async fn serial_test_execute_cylinder() {
+    let code = include_str!("inputs/cylinder.kcl");
+
+    let result = execute_and_snapshot(code).await.unwrap();
+    twenty_twenty::assert_image("tests/executor/outputs/cylinder.png", &result, 0.999);
+}
+
 #[tokio::test(flavor = "multi_thread")]
 async fn serial_test_execute_kittycad_svg() {
    let code = include_str!("inputs/kittycad_svg.kcl");
@ -504,3 +518,23 @@ show(part)"#;
    let result = execute_and_snapshot(code).await.unwrap();
    twenty_twenty::assert_image("tests/executor/outputs/rounded_with_holes.png", &result, 0.999);
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn serial_test_top_level_expression() {
+    let code = r#"fn circle = (pos, radius) => {
+  const sg = startSketchOn('XY')
+    |> startProfileAt([pos[0] + radius, pos[1]], %)
+    |> arc({
+       angle_end: 360,
+       angle_start: 0,
+       radius: radius
+     }, %)
+    |> close(%)
+  return sg
+}
+
+circle([0,0], 22) |> extrude(14, %)"#;
+
+    let result = execute_and_snapshot(code).await.unwrap();
+    twenty_twenty::assert_image("tests/executor/outputs/top_level_expression.png", &result, 0.999);
+}
--- a/src/wasm-lib/tests/executor/outputs/cylinder.png
+++ b/src/wasm-lib/tests/executor/outputs/cylinder.png
--- a/src/wasm-lib/tests/executor/outputs/kittycad_svg.png
+++ b/src/wasm-lib/tests/executor/outputs/kittycad_svg.png
--- a/src/wasm-lib/tests/executor/outputs/top_level_expression.png
+++ b/src/wasm-lib/tests/executor/outputs/top_level_expression.png
--- a/src/wasm-lib/tests/modify/main.rs
+++ b/src/wasm-lib/tests/modify/main.rs
@ -1,8 +1,11 @@
+use std::sync::Arc;
+
 use anyhow::Result;
 use kcl_lib::{
    ast::{modify::modify_ast_for_sketch, types::Program},
    engine::EngineManager,
    executor::{ExecutorContext, MemoryItem, PlaneType, SourceRange},
+    std::StdLib,
 };
 use kittycad::types::{ModelingCmd, Point3D};
 use pretty_assertions::assert_eq;
@ -39,7 +42,11 @@ async fn setup(code: &str, name: &str) -> Result<(ExecutorContext, Program, uuid
    let mut mem: kcl_lib::executor::ProgramMemory = Default::default();
    let engine = kcl_lib::engine::EngineConnection::new(ws).await?;
    let planes = kcl_lib::executor::DefaultPlanes::new(&engine).await?;
-    let ctx = ExecutorContext { engine, planes };
+    let ctx = ExecutorContext {
+        engine,
+        planes,
+        stdlib: Arc::new(StdLib::default()),
+    };
    let memory = kcl_lib::executor::execute(program.clone(), &mut mem, kcl_lib::executor::BodyType::Root, &ctx).await?;

    // We need to get the sketch ID.
--- a/wdio.conf.js
+++ b/wdio.conf.js
@ -2,11 +2,14 @@ const os = require('os')
 const path = require('path')
 const { spawn } = require('child_process')

+
+
 // keep track of the `tauri-driver` child process
 let tauriDriver

+const mode = process.env.MODE
 const application =
-  process.env.E2E_APPLICATION || './src-tauri/target/release/kittycad-modeling'
+  process.env.E2E_APPLICATION || `./src-tauri/target/${mode}/kittycad-modeling`

 exports.config = {
  port: 4444,
--- a/yarn.lock
+++ b/yarn.lock