Debugging main

.eslintrc

@@ -5,24 +5,16 @@
     },
     "plugins": [
       "css-modules",
-      "jest",
-      "react",
       "suggest-no-throw",
-      "@typescript-eslint"
     ],
     "extends": [
+      "react-app",
+      "react-app/jest",
       "plugin:css-modules/recommended"
     ],
     "rules": {
       "@typescript-eslint/no-floating-promises": "error",
       "@typescript-eslint/no-misused-promises": "error",
-      "no-restricted-globals": [
-        "error",
-        {
-          "name": "isNaN",
-          "message": "Use Number.isNaN() instead."
-        }
-      ],
       "semi": [
         "error",
         "never"

.github/ci-cd-scripts/playwright-electron.sh

@@ -21,7 +21,7 @@ if [[ ! -f "test-results/.last-run.json" ]]; then
 fi
 
 retry=1
-max_retrys=5
+max_retrys=4
 
 # retry failed tests, doing our own retries because using inbuilt playwright retries causes connection issues
 while [[ $retry -le $max_retrys ]]; do

e2e/playwright/fixtures/toolbarFixture.ts

@@ -14,7 +14,6 @@ export class ToolbarFixture {
 
   extrudeButton!: Locator
   loftButton!: Locator
-  sweepButton!: Locator
   shellButton!: Locator
   offsetPlaneButton!: Locator
   startSketchBtn!: Locator
@@ -41,7 +40,6 @@ export class ToolbarFixture {
     this.page = page
     this.extrudeButton = page.getByTestId('extrude')
     this.loftButton = page.getByTestId('loft')
-    this.sweepButton = page.getByTestId('sweep')
     this.shellButton = page.getByTestId('shell')
     this.offsetPlaneButton = page.getByTestId('plane-offset')
     this.startSketchBtn = page.getByTestId('sketch')

e2e/playwright/point-click.spec.ts

@@ -934,104 +934,6 @@ loft001 = loft([sketch001, sketch002])
   })
 })
 
-test(`Sweep point-and-click`, async ({
-  context,
-  page,
-  homePage,
-  scene,
-  editor,
-  toolbar,
-  cmdBar,
-}) => {
-  const initialCode = `sketch001 = startSketchOn('YZ')
-  |> circle({
-       center = [0, 0],
-       radius = 500
-     }, %)
-sketch002 = startSketchOn('XZ')
-  |> startProfileAt([0, 0], %)
-  |> xLine(-500, %)
-  |> tangentialArcTo([-2000, 500], %)
-`
-  await context.addInitScript((initialCode) => {
-    localStorage.setItem('persistCode', initialCode)
-  }, initialCode)
-  await page.setBodyDimensions({ width: 1000, height: 500 })
-  await homePage.goToModelingScene()
-  await scene.waitForExecutionDone()
-
-  // One dumb hardcoded screen pixel value
-  const testPoint = { x: 700, y: 250 }
-  const [clickOnSketch1] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
-  const [clickOnSketch2] = scene.makeMouseHelpers(testPoint.x - 50, testPoint.y)
-  const sweepDeclaration = 'sweep001 = sweep({ path = sketch002 }, sketch001)'
-
-  await test.step(`Look for sketch001`, async () => {
-    await toolbar.closePane('code')
-    await scene.expectPixelColor([53, 53, 53], testPoint, 15)
-  })
-
-  await test.step(`Go through the command bar flow`, async () => {
-    await toolbar.sweepButton.click()
-    await cmdBar.expectState({
-      commandName: 'Sweep',
-      currentArgKey: 'profile',
-      currentArgValue: '',
-      headerArguments: {
-        Path: '',
-        Profile: '',
-      },
-      highlightedHeaderArg: 'profile',
-      stage: 'arguments',
-    })
-    await clickOnSketch1()
-    await cmdBar.expectState({
-      commandName: 'Sweep',
-      currentArgKey: 'path',
-      currentArgValue: '',
-      headerArguments: {
-        Path: '',
-        Profile: '1 face',
-      },
-      highlightedHeaderArg: 'path',
-      stage: 'arguments',
-    })
-    await clickOnSketch2()
-    await cmdBar.expectState({
-      commandName: 'Sweep',
-      headerArguments: {
-        Path: '1 face',
-        Profile: '1 face',
-      },
-      stage: 'review',
-    })
-    await cmdBar.progressCmdBar()
-  })
-
-  await test.step(`Confirm code is added to the editor, scene has changed`, async () => {
-    await scene.expectPixelColor([135, 64, 73], testPoint, 15)
-    await toolbar.openPane('code')
-    await editor.expectEditor.toContain(sweepDeclaration)
-    await editor.expectState({
-      diagnostics: [],
-      activeLines: [sweepDeclaration],
-      highlightedCode: '',
-    })
-    await toolbar.closePane('code')
-  })
-
-  await test.step('Delete sweep via feature tree selection', async () => {
-    await toolbar.openPane('feature-tree')
-    await page.waitForTimeout(500)
-    const operationButton = await toolbar.getFeatureTreeOperation('Sweep', 0)
-    await operationButton.click({ button: 'left' })
-    await page.keyboard.press('Backspace')
-    await page.waitForTimeout(500)
-    await toolbar.closePane('feature-tree')
-    await scene.expectPixelColor([53, 53, 53], testPoint, 15)
-  })
-})
-
 const shellPointAndClickCapCases = [
   { shouldPreselect: true },
   { shouldPreselect: false },
@@ -1280,11 +1182,9 @@ shellSketchOnFacesCases.forEach((initialCode, index) => {
         commandName: 'Shell',
       })
       await clickOnCap()
-      await page.waitForTimeout(500)
       await cmdBar.progressCmdBar()
       await page.waitForTimeout(500)
       await cmdBar.progressCmdBar()
-      await page.waitForTimeout(500)
       await cmdBar.expectState({
         stage: 'review',
         headerArguments: {

flake.lock

@@ -2,11 +2,11 @@
   "nodes": {
     "nixpkgs": {
       "locked": {
-        "lastModified": 1736320768,
-        "narHash": "sha256-nIYdTAiKIGnFNugbomgBJR+Xv5F1ZQU+HfaBqJKroC0=",
+        "lastModified": 1721933792,
+        "narHash": "sha256-zYVwABlQnxpbaHMfX6Wt9jhyQstFYwN2XjleOJV3VVg=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "4bc9c909d9ac828a039f288cf872d16d38185db8",
+        "rev": "2122a9b35b35719ad9a395fe783eabb092df01b1",
         "type": "github"
       },
       "original": {
@@ -18,11 +18,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1728538411,
-        "narHash": "sha256-f0SBJz1eZ2yOuKUr5CA9BHULGXVSn6miBuUWdTyhUhU=",
+        "lastModified": 1718428119,
+        "narHash": "sha256-WdWDpNaq6u1IPtxtYHHWpl5BmabtpmLnMAx0RdJ/vo8=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "b69de56fac8c2b6f8fd27f2eca01dcda8e0a4221",
+        "rev": "e6cea36f83499eb4e9cd184c8a8e823296b50ad5",
         "type": "github"
       },
       "original": {
@@ -43,11 +43,11 @@
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1736476219,
-        "narHash": "sha256-+qyv3QqdZCdZ3cSO/cbpEY6tntyYjfe1bB12mdpNFaY=",
+        "lastModified": 1721960387,
+        "narHash": "sha256-o21ax+745ETGXrcgc/yUuLw1SI77ymp3xEpJt+w/kks=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "de30cc5963da22e9742bbbbb9a3344570ed237b9",
+        "rev": "9cbf831c5b20a53354fc12758abd05966f9f1699",
         "type": "github"
       },
       "original": {

package.json

@@ -91,8 +91,8 @@
     "build:wasm": "yarn wasm-prep && cd src/wasm-lib && wasm-pack build --release --target web --out-dir pkg && cargo test -p kcl-lib export_bindings && cd ../.. && yarn isomorphic-copy-wasm && yarn fmt",
     "remove-importmeta": "sed -i 's/import.meta.url/window.location.origin/g' \"./src/wasm-lib/pkg/wasm_lib.js\"; sed -i '' 's/import.meta.url/window.location.origin/g' \"./src/wasm-lib/pkg/wasm_lib.js\" || echo \"sed for both mac and linux\"",
     "wasm-prep": "rimraf src/wasm-lib/pkg && mkdirp src/wasm-lib/pkg && rimraf src/wasm-lib/kcl/bindings",
-    "lint-fix": "eslint --fix --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src",
-    "lint": "eslint --max-warnings 0 --ext .ts --ext .tsx src e2e packages/codemirror-lsp-client/src",
+    "lint-fix": "eslint --fix src e2e packages/codemirror-lsp-client",
+    "lint": "eslint --max-warnings 0 src e2e packages/codemirror-lsp-client",
     "files:set-version": "echo \"$(jq --arg v \"$VERSION\" '.version=$v' package.json --indent 2)\" > package.json",
     "files:set-notes": "./scripts/set-files-notes.sh",
     "files:flip-to-nightly": "./scripts/flip-files-to-nightly.sh",
@@ -171,6 +171,8 @@
     "@types/uuid": "^9.0.8",
     "@types/wicg-file-system-access": "^2023.10.5",
     "@types/ws": "^8.5.13",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
     "@vitejs/plugin-react": "^4.3.0",
     "@vitest/web-worker": "^1.5.0",
     "@xstate/cli": "^0.5.17",
@@ -180,10 +182,9 @@
     "electron-builder": "24.13.3",
     "electron-notarize": "1.2.2",
     "eslint": "^8.0.1",
+    "eslint-config-react-app": "^7.0.1",
     "eslint-plugin-css-modules": "^2.12.0",
     "eslint-plugin-import": "^2.30.0",
-    "eslint-plugin-jest": "^28.10.0",
-    "eslint-plugin-react": "^7.37.3",
     "eslint-plugin-suggest-no-throw": "^1.0.0",
     "happy-dom": "^16.3.0",
     "http-server": "^14.1.1",
@@ -199,7 +200,6 @@
     "tailwindcss": "^3.4.1",
     "ts-node": "^10.0.0",
     "typescript": "^5.7.2",
-    "typescript-eslint": "^8.19.1",
     "vite": "^5.4.6",
     "vite-plugin-package-version": "^1.1.0",
     "vite-tsconfig-paths": "^4.3.2",

packages/codemirror-lsp-client/src/client/codec/demuxer.ts

@@ -42,7 +42,7 @@ export default class StreamDemuxer extends Queue<Uint8Array> {
           // try to parse the content-length from the headers
           const length = parseInt(match[1])
 
-          if (Number.isNaN(length))
+          if (isNaN(length))
             return Promise.reject(new Error('invalid content length'))
 
           // slice the headers since we now have the content length

playwright.electron.config.ts

@@ -32,9 +32,10 @@ export default defineConfig({
   },
   projects: [
     {
-      name: 'chromium',
+      name: 'Google Chrome',
       use: {
         ...devices['Desktop Chrome'],
+        channel: 'chrome',
         contextOptions: {
           /* Chromium is the only one with these permission types */
           permissions: ['clipboard-write', 'clipboard-read'],

src/components/ModelingMachineProvider.tsx

@@ -157,38 +157,39 @@ export const ModelingMachineProvider = ({
         'enable copilot': () => {
           editorManager.setCopilotEnabled(true)
         },
-        'sketch exit execute': ({ context: { store } }) => {
-          // TODO: Remove this async callback.  For some reason eslint wouldn't
-          // let me disable @typescript-eslint/no-misused-promises for the line.
-          ;(async () => {
-            // When cancelling the sketch mode we should disable sketch mode within the engine.
-            await engineCommandManager.sendSceneCommand({
-              type: 'modeling_cmd_req',
-              cmd_id: uuidv4(),
-              cmd: { type: 'sketch_mode_disable' },
-            })
+        // tsc reports this typing as perfectly fine, but eslint is complaining.
+        // It's actually nonsensical, so I'm quieting.
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        'sketch exit execute': async ({
+          context: { store },
+        }): Promise<void> => {
+          // When cancelling the sketch mode we should disable sketch mode within the engine.
+          await engineCommandManager.sendSceneCommand({
+            type: 'modeling_cmd_req',
+            cmd_id: uuidv4(),
+            cmd: { type: 'sketch_mode_disable' },
+          })
 
-            sceneInfra.camControls.syncDirection = 'clientToEngine'
+          sceneInfra.camControls.syncDirection = 'clientToEngine'
 
-            if (cameraProjection.current === 'perspective') {
-              await sceneInfra.camControls.snapToPerspectiveBeforeHandingBackControlToEngine()
-            }
+          if (cameraProjection.current === 'perspective') {
+            await sceneInfra.camControls.snapToPerspectiveBeforeHandingBackControlToEngine()
+          }
 
-            sceneInfra.camControls.syncDirection = 'engineToClient'
+          sceneInfra.camControls.syncDirection = 'engineToClient'
 
-            store.videoElement?.pause()
+          store.videoElement?.pause()
 
-            return kclManager
-              .executeCode()
-              .then(() => {
-                if (engineCommandManager.engineConnection?.idleMode) return
+          return kclManager
+            .executeCode()
+            .then(() => {
+              if (engineCommandManager.engineConnection?.idleMode) return
 
-                store.videoElement?.play().catch((e) => {
-                  console.warn('Video playing was prevented', e)
-                })
+              store.videoElement?.play().catch((e) => {
+                console.warn('Video playing was prevented', e)
               })
-              .catch(reportRejection)
-          })().catch(reportRejection)
+            })
+            .catch(reportRejection)
         },
         'Set mouse state': assign(({ context, event }) => {
           if (event.type !== 'Set mouse state') return {}

src/lang/modifyAst.ts

@@ -374,37 +374,6 @@ export function loftSketches(
   }
 }
 
-export function addSweep(
-  node: Node<Program>,
-  profileDeclarator: VariableDeclarator,
-  pathDeclarator: VariableDeclarator
-): {
-  modifiedAst: Node<Program>
-  pathToNode: PathToNode
-} {
-  const modifiedAst = structuredClone(node)
-  const name = findUniqueName(node, KCL_DEFAULT_CONSTANT_PREFIXES.SWEEP)
-  const sweep = createCallExpressionStdLib('sweep', [
-    createObjectExpression({ path: createIdentifier(pathDeclarator.id.name) }),
-    createIdentifier(profileDeclarator.id.name),
-  ])
-  const declaration = createVariableDeclaration(name, sweep)
-  modifiedAst.body.push(declaration)
-  const pathToNode: PathToNode = [
-    ['body', ''],
-    [modifiedAst.body.length - 1, 'index'],
-    ['declaration', 'VariableDeclaration'],
-    ['init', 'VariableDeclarator'],
-    ['arguments', 'CallExpression'],
-    [0, 'index'],
-  ]
-
-  return {
-    modifiedAst,
-    pathToNode,
-  }
-}
-
 export function revolveSketch(
   node: Node<Program>,
   pathToNode: PathToNode,

src/lang/modifyAst/addRevolve.ts

@@ -29,9 +29,7 @@ export function revolveSketch(
   pathToSketchNode: PathToNode,
   shouldPipe = false,
   angle: Expr = createLiteral(4),
-  axisOrEdge: string,
-  axis: string,
-  edge: Selections
+  axis: Selections
 ):
   | {
       modifiedAst: Node<Program>
@@ -43,34 +41,31 @@ export function revolveSketch(
   const sketchNode = getNodeFromPath(clonedAst, pathToSketchNode)
   if (err(sketchNode)) return sketchNode
 
-  let generatedAxis
+  // testing code
+  const pathToAxisSelection = getNodePathFromSourceRange(
+    clonedAst,
+    axis.graphSelections[0]?.codeRef.range
+  )
 
-  if (axisOrEdge === 'Edge') {
-    const pathToAxisSelection = getNodePathFromSourceRange(
-      clonedAst,
-      edge.graphSelections[0]?.codeRef.range
-    )
-    const lineNode = getNodeFromPath<CallExpression>(
-      clonedAst,
-      pathToAxisSelection,
-      'CallExpression'
-    )
-    if (err(lineNode)) return lineNode
+  const lineNode = getNodeFromPath<CallExpression>(
+    clonedAst,
+    pathToAxisSelection,
+    'CallExpression'
+  )
+  if (err(lineNode)) return lineNode
 
-    const tagResult = mutateAstWithTagForSketchSegment(
-      clonedAst,
-      pathToAxisSelection
-    )
+  // TODO Kevin: What if |> close(%)?
+  // TODO Kevin: What if opposite edge
+  // TODO Kevin: What if the edge isn't planar to the sketch?
+  // TODO Kevin: add a tag.
+  const tagResult = mutateAstWithTagForSketchSegment(
+    clonedAst,
+    pathToAxisSelection
+  )
 
-    // Have the tag whether it is already created or a new one is generated
-    if (err(tagResult)) return tagResult
-    const { tag } = tagResult
-    const axisSelection = edge?.graphSelections[0]?.artifact
-    if (!axisSelection) return new Error('Generated axis selection is missing.')
-    generatedAxis = getEdgeTagCall(tag, axisSelection)
-  } else {
-    generatedAxis = createLiteral(axis)
-  }
+  // Have the tag whether it is already created or a new one is generated
+  if (err(tagResult)) return tagResult
+  const { tag } = tagResult
 
   /* Original Code */
   const { node: sketchExpression } = sketchNode
@@ -96,12 +91,14 @@ export function revolveSketch(
     shallowPath: sketchPathToDecleration,
   } = sketchVariableDeclaratorNode
 
-  if (!generatedAxis) return new Error('Generated axis selection is missing.')
+  const axisSelection = axis?.graphSelections[0]?.artifact
+
+  if (!axisSelection) return new Error('Axis selection is missing.')
 
   const revolveCall = createCallExpressionStdLib('revolve', [
     createObjectExpression({
       angle: angle,
-      axis: generatedAxis,
+      axis: getEdgeTagCall(tag, axisSelection),
     }),
     createIdentifier(sketchVariableDeclarator.id.name),
   ])

src/lang/std/artifactGraph.ts

@@ -77,7 +77,7 @@ interface SegmentArtifactRich extends BaseArtifact {
 /** A Sweep is a more generic term for extrude, revolve, loft and sweep*/
 interface SweepArtifact extends BaseArtifact {
   type: 'sweep'
-  subType: 'extrusion' | 'revolve' | 'loft' | 'sweep'
+  subType: 'extrusion' | 'revolve' | 'loft'
   pathId: string
   surfaceIds: Array<string>
   edgeIds: Array<string>
@@ -85,7 +85,7 @@ interface SweepArtifact extends BaseArtifact {
 }
 interface SweepArtifactRich extends BaseArtifact {
   type: 'sweep'
-  subType: 'extrusion' | 'revolve' | 'loft' | 'sweep'
+  subType: 'extrusion' | 'revolve' | 'loft'
   path: PathArtifact
   surfaces: Array<WallArtifact | CapArtifact>
   edges: Array<SweepEdge>
@@ -377,11 +377,7 @@ export function getArtifactsToUpdate({
         })
     }
     return returnArr
-  } else if (
-    cmd.type === 'extrude' ||
-    cmd.type === 'revolve' ||
-    cmd.type === 'sweep'
-  ) {
+  } else if (cmd.type === 'extrude' || cmd.type === 'revolve') {
     const subType = cmd.type === 'extrude' ? 'extrusion' : cmd.type
     returnArr.push({
       id,

src/lang/std/sketchcombos.ts

@@ -445,8 +445,10 @@ const setHorzVertDistanceConstraintLineCreateNode =
     ])
 
     const makeBinExp = (index: 0 | 1) => {
+      console.error("ADAM args", args)
       const arg = getArgLiteralVal(args?.[index].expr)
       const refNum = referencedSegment?.to?.[index]
+      console.error("ADAM arg and refNum:", arg, refNum)
       if (err(arg) || !isNum(refNum)) return REF_NUM_ERR
       return createBinaryExpressionWithUnary([
         createSegEnd(referenceSegName, isX),

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -37,10 +37,6 @@ export type ModelingCommandSchema = {
     // result: (typeof EXTRUSION_RESULTS)[number]
     distance: KclCommandValue
   }
-  Sweep: {
-    path: Selections
-    profile: Selections
-  }
   Loft: {
     selection: Selections
   }
@@ -51,9 +47,7 @@ export type ModelingCommandSchema = {
   Revolve: {
     selection: Selections
     angle: KclCommandValue
-    axisOrEdge: string
-    axis: string
-    edge: Selections
+    axis: Selections
   }
   Fillet: {
     // todo
@@ -296,33 +290,6 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
       },
     },
   },
-  Sweep: {
-    description:
-      'Create a 3D body by moving a sketch region along an arbitrary path.',
-    icon: 'sweep',
-    status: 'development',
-    needsReview: true,
-    args: {
-      profile: {
-        inputType: 'selection',
-        selectionTypes: ['solid2D'],
-        required: true,
-        skip: true,
-        multiple: false,
-        // TODO: add dry-run validation
-        warningMessage:
-          'The sweep workflow is new and under tested. Please break it and report issues.',
-      },
-      path: {
-        inputType: 'selection',
-        selectionTypes: ['segment', 'path'],
-        required: true,
-        skip: true,
-        multiple: false,
-        // TODO: add dry-run validation
-      },
-    },
-  },
   Loft: {
     description: 'Create a 3D body by blending between two or more sketches',
     icon: 'loft',
@@ -357,10 +324,10 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
       },
     },
   },
+  // TODO: Update this configuration, copied from extrude for MVP of revolve, specifically the args.selection
   Revolve: {
     description: 'Create a 3D body by rotating a sketch region about an axis.',
     icon: 'revolve',
-    status: 'development',
     needsReview: true,
     args: {
       selection: {
@@ -369,34 +336,9 @@ export const modelingMachineCommandConfig: StateMachineCommandSetConfig<
         multiple: false, // TODO: multiple selection
         required: true,
         skip: true,
-        warningMessage:
-          'The revolve workflow is new and under tested. Please break it and report issues.',
-      },
-      axisOrEdge: {
-        inputType: 'options',
-        required: true,
-        defaultValue: 'Axis',
-        options: [
-          { name: 'Axis', isCurrent: true, value: 'Axis' },
-          { name: 'Edge', isCurrent: false, value: 'Edge' },
-        ],
       },
       axis: {
-        required: (commandContext) =>
-          ['Axis'].includes(
-            commandContext.argumentsToSubmit.axisOrEdge as string
-          ),
-        inputType: 'options',
-        options: [
-          { name: 'X Axis', isCurrent: true, value: 'X' },
-          { name: 'Y Axis', isCurrent: false, value: 'Y' },
-        ],
-      },
-      edge: {
-        required: (commandContext) =>
-          ['Edge'].includes(
-            commandContext.argumentsToSubmit.axisOrEdge as string
-          ),
+        required: true,
         inputType: 'selection',
         selectionTypes: ['segment', 'sweepEdge', 'edgeCutEdge'],
         multiple: false,

src/lib/commandBarConfigs/validators.ts

@@ -68,7 +68,7 @@ export const revolveAxisValidator = async ({
   }
 
   const sketchSelection = artifact.pathId
-  let edgeSelection = data.edge.graphSelections[0].artifact?.id
+  let edgeSelection = data.axis.graphSelections[0].artifact?.id
 
   if (!sketchSelection) {
     return 'Unable to revolve, sketch is missing'
@@ -101,7 +101,7 @@ export const revolveAxisValidator = async ({
     return true
   } else {
     // return error message for the toast
-    return 'Unable to revolve with selected edge'
+    return 'Unable to revolve with selected axis'
   }
 }
 

src/lib/constants.ts

@@ -53,7 +53,6 @@ export const KCL_DEFAULT_CONSTANT_PREFIXES = {
   SKETCH: 'sketch',
   EXTRUDE: 'extrude',
   LOFT: 'loft',
-  SWEEP: 'sweep',
   SHELL: 'shell',
   SEGMENT: 'seg',
   REVOLVE: 'revolve',

src/lib/createMachineCommand.ts

@@ -15,7 +15,6 @@ import {
   StateMachineCommandSetSchema,
 } from './commandTypes'
 import { DEV } from 'env'
-import { IS_NIGHTLY_OR_DEBUG } from 'routes/Settings'
 
 interface CreateMachineCommandProps<
   T extends AnyStateMachine,
@@ -85,7 +84,7 @@ export function createMachineCommand<
   } else if ('status' in commandConfig) {
     const { status } = commandConfig
     if (status === 'inactive') return null
-    if (status === 'development' && !(DEV || IS_NIGHTLY_OR_DEBUG)) return null
+    if (status === 'development' && !DEV) return null
   }
 
   const icon = ('icon' in commandConfig && commandConfig.icon) || undefined

src/lib/toolbar.ts

@@ -8,7 +8,6 @@ import {
   modelingMachine,
   pipeHasCircle,
 } from 'machines/modelingMachine'
-import { IS_NIGHTLY_OR_DEBUG } from 'routes/Settings'
 import { EventFrom, StateFrom } from 'xstate'
 
 export type ToolbarModeName = 'modeling' | 'sketching'
@@ -104,7 +103,7 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
             data: { name: 'Revolve', groupId: 'modeling' },
           }),
         icon: 'revolve',
-        status: DEV || IS_NIGHTLY_OR_DEBUG ? 'available' : 'kcl-only',
+        status: DEV ? 'available' : 'kcl-only',
         title: 'Revolve',
         hotkey: 'R',
         description:
@@ -119,21 +118,17 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
       },
       {
         id: 'sweep',
-        onClick: ({ commandBarSend }) =>
-          commandBarSend({
-            type: 'Find and select command',
-            data: { name: 'Sweep', groupId: 'modeling' },
-          }),
+        onClick: () => console.error('Sweep not yet implemented'),
         icon: 'sweep',
-        status: DEV || IS_NIGHTLY_OR_DEBUG ? 'available' : 'kcl-only',
+        status: 'unavailable',
         title: 'Sweep',
         hotkey: 'W',
         description:
           'Create a 3D body by moving a sketch region along an arbitrary path.',
         links: [
           {
-            label: 'KCL docs',
-            url: 'https://zoo.dev/docs/kcl/sweep',
+            label: 'GitHub discussion',
+            url: 'https://github.com/KittyCAD/modeling-app/discussions/498',
           },
         ],
       },
@@ -166,7 +161,7 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
             data: { name: 'Fillet', groupId: 'modeling' },
           }),
         icon: 'fillet3d',
-        status: DEV || IS_NIGHTLY_OR_DEBUG ? 'available' : 'kcl-only',
+        status: DEV ? 'available' : 'kcl-only',
         title: 'Fillet',
         hotkey: 'F',
         description: 'Round the edges of a 3D solid.',

src/lib/utils.ts

@@ -345,7 +345,7 @@ export function onDragNumberCalculation(text: string, e: MouseEvent) {
   )
   const newVal = roundOff(addition, precision)
 
-  if (Number.isNaN(newVal)) {
+  if (isNaN(newVal)) {
     return
   }
 

src/machines/modelingMachine.ts

@@ -45,7 +45,6 @@ import {
 import { revolveSketch } from 'lang/modifyAst/addRevolve'
 import {
   addOffsetPlane,
-  addSweep,
   deleteFromSelection,
   extrudeSketch,
   loftSketches,
@@ -267,7 +266,6 @@ export type ModelingMachineEvent =
   | { type: 'Export'; data: ModelingCommandSchema['Export'] }
   | { type: 'Make'; data: ModelingCommandSchema['Make'] }
   | { type: 'Extrude'; data?: ModelingCommandSchema['Extrude'] }
-  | { type: 'Sweep'; data?: ModelingCommandSchema['Sweep'] }
   | { type: 'Loft'; data?: ModelingCommandSchema['Loft'] }
   | { type: 'Shell'; data?: ModelingCommandSchema['Shell'] }
   | { type: 'Revolve'; data?: ModelingCommandSchema['Revolve'] }
@@ -687,7 +685,7 @@ export const modelingMachine = setup({
       if (event.type !== 'Revolve') return
       ;(async () => {
         if (!event.data) return
-        const { selection, angle, axis, edge, axisOrEdge } = event.data
+        const { selection, angle, axis } = event.data
         let ast = kclManager.ast
         if (
           'variableName' in angle &&
@@ -712,9 +710,7 @@ export const modelingMachine = setup({
           'variableName' in angle
             ? angle.variableIdentifierAst
             : angle.valueAst,
-          axisOrEdge,
-          axis,
-          edge
+          axis
         )
         if (trap(revolveSketchRes)) return
         const { modifiedAst, pathToRevolveArg } = revolveSketchRes
@@ -1546,66 +1542,6 @@ export const modelingMachine = setup({
         }
       }
     ),
-    sweepAstMod: fromPromise(
-      async ({
-        input,
-      }: {
-        input: ModelingCommandSchema['Sweep'] | undefined
-      }) => {
-        if (!input) return new Error('No input provided')
-        // Extract inputs
-        const ast = kclManager.ast
-        const { profile, path } = input
-
-        // Find the profile declaration
-        const profileNodePath = getNodePathFromSourceRange(
-          ast,
-          profile.graphSelections[0].codeRef.range
-        )
-        const profileNode = getNodeFromPath<VariableDeclarator>(
-          ast,
-          profileNodePath,
-          'VariableDeclarator'
-        )
-        if (err(profileNode)) {
-          return new Error("Couldn't parse profile selection")
-        }
-        const profileDeclarator = profileNode.node
-
-        // Find the path declaration
-        const pathNodePath = getNodePathFromSourceRange(
-          ast,
-          path.graphSelections[0].codeRef.range
-        )
-        const pathNode = getNodeFromPath<VariableDeclarator>(
-          ast,
-          pathNodePath,
-          'VariableDeclarator'
-        )
-        if (err(pathNode)) {
-          return new Error("Couldn't parse path selection")
-        }
-        const pathDeclarator = pathNode.node
-
-        // Perform the sweep
-        const sweepRes = addSweep(ast, profileDeclarator, pathDeclarator)
-        const updateAstResult = await kclManager.updateAst(
-          sweepRes.modifiedAst,
-          true,
-          {
-            focusPath: [sweepRes.pathToNode],
-          }
-        )
-
-        await codeManager.updateEditorWithAstAndWriteToFile(
-          updateAstResult.newAst
-        )
-
-        if (updateAstResult?.selections) {
-          editorManager.selectRange(updateAstResult?.selections)
-        }
-      }
-    ),
     loftAstMod: fromPromise(
       async ({
         input,
@@ -1801,11 +1737,6 @@ export const modelingMachine = setup({
           reenter: false,
         },
 
-        Sweep: {
-          target: 'Applying sweep',
-          reenter: true,
-        },
-
         Loft: {
           target: 'Applying loft',
           reenter: true,
@@ -2598,19 +2529,6 @@ export const modelingMachine = setup({
       },
     },
 
-    'Applying sweep': {
-      invoke: {
-        src: 'sweepAstMod',
-        id: 'sweepAstMod',
-        input: ({ event }) => {
-          if (event.type !== 'Sweep') return undefined
-          return event.data
-        },
-        onDone: ['idle'],
-        onError: ['idle'],
-      },
-    },
-
     'Applying loft': {
       invoke: {
         src: 'loftAstMod',

src/routes/Settings.tsx

@@ -32,8 +32,6 @@ export const PACKAGE_NAME = isDesktop()
 
 export const IS_NIGHTLY = PACKAGE_NAME.indexOf('-nightly') > -1
 
-export const IS_NIGHTLY_OR_DEBUG = IS_NIGHTLY || APP_VERSION === '0.0.0'
-
 export function getReleaseUrl(version: string = APP_VERSION) {
   return `https://github.com/KittyCAD/modeling-app/releases/tag/${
     IS_NIGHTLY ? 'nightly-' : ''

src/wasm-lib/kcl-to-core/src/conn_mock_core.rs

@@ -502,6 +502,4 @@ impl kcl_lib::EngineManager for EngineConnection {
             })),
         }
     }
-
-    async fn close(&self) {}
 }

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

@@ -37,10 +37,9 @@ enum SocketHealth {
 }
 
 type WebSocketTcpWrite = futures::stream::SplitSink<tokio_tungstenite::WebSocketStream<reqwest::Upgraded>, WsMsg>;
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct EngineConnection {
     engine_req_tx: mpsc::Sender<ToEngineReq>,
-    shutdown_tx: mpsc::Sender<()>,
     responses: Arc<DashMap<uuid::Uuid, WebSocketResponse>>,
     pending_errors: Arc<Mutex<Vec<String>>>,
     #[allow(dead_code)]
@@ -131,49 +130,21 @@ struct ToEngineReq {
 
 impl EngineConnection {
     /// Start waiting for incoming engine requests, and send each one over the WebSocket to the engine.
-    async fn start_write_actor(
-        mut tcp_write: WebSocketTcpWrite,
-        mut engine_req_rx: mpsc::Receiver<ToEngineReq>,
-        mut shutdown_rx: mpsc::Receiver<()>,
-    ) {
-        loop {
-            tokio::select! {
-                maybe_req = engine_req_rx.recv() => {
-                    match maybe_req {
-                        Some(ToEngineReq { req, request_sent }) => {
-                            // Decide whether to send as binary or text,
-                            // then send to the engine.
-                            let res = if let WebSocketRequest::ModelingCmdReq(ModelingCmdReq {
-                                cmd: ModelingCmd::ImportFiles { .. },
-                                cmd_id: _,
-                            }) = &req
-                            {
-                                Self::inner_send_to_engine_binary(req, &mut tcp_write).await
-                            } else {
-                                Self::inner_send_to_engine(req, &mut tcp_write).await
-                            };
-
-                            // Let the caller know we’ve sent the request (ok or error).
-                            let _ = request_sent.send(res);
-                        }
-                        None => {
-                            // The engine_req_rx channel has closed, so no more requests.
-                            // We'll gracefully exit the loop and close the engine.
-                            break;
-                        }
-                    }
-                },
-
-                // If we get a shutdown signal, close the engine immediately and return.
-                _ = shutdown_rx.recv() => {
-                    let _ = Self::inner_close_engine(&mut tcp_write).await;
-                    return;
-                }
-            }
+    async fn start_write_actor(mut tcp_write: WebSocketTcpWrite, mut engine_req_rx: mpsc::Receiver<ToEngineReq>) {
+        while let Some(req) = engine_req_rx.recv().await {
+            let ToEngineReq { req, request_sent } = req;
+            let res = if let WebSocketRequest::ModelingCmdReq(ModelingCmdReq {
+                cmd: ModelingCmd::ImportFiles { .. },
+                cmd_id: _,
+            }) = &req
+            {
+                // Send it as binary.
+                Self::inner_send_to_engine_binary(req, &mut tcp_write).await
+            } else {
+                Self::inner_send_to_engine(req, &mut tcp_write).await
+            };
+            let _ = request_sent.send(res);
         }
-
-        // If we exit the loop (e.g. engine_req_rx was closed),
-        // still gracefully close the engine before returning.
         let _ = Self::inner_close_engine(&mut tcp_write).await;
     }
 
@@ -223,8 +194,7 @@ impl EngineConnection {
 
         let (tcp_write, tcp_read) = ws_stream.split();
         let (engine_req_tx, engine_req_rx) = mpsc::channel(10);
-        let (shutdown_tx, shutdown_rx) = mpsc::channel(1);
-        tokio::task::spawn(Self::start_write_actor(tcp_write, engine_req_rx, shutdown_rx));
+        tokio::task::spawn(Self::start_write_actor(tcp_write, engine_req_rx));
 
         let mut tcp_read = TcpRead { stream: tcp_read };
 
@@ -334,7 +304,6 @@ impl EngineConnection {
 
         Ok(EngineConnection {
             engine_req_tx,
-            shutdown_tx,
             tcp_read_handle: Arc::new(TcpReadHandle {
                 handle: Arc::new(tcp_read_handle),
             }),
@@ -515,15 +484,4 @@ impl EngineManager for EngineConnection {
     fn get_session_data(&self) -> Option<ModelingSessionData> {
         self.session_data.lock().unwrap().clone()
     }
-
-    async fn close(&self) {
-        let _ = self.shutdown_tx.send(()).await;
-        loop {
-            if let Ok(guard) = self.socket_health.lock() {
-                if *guard == SocketHealth::Inactive {
-                    return;
-                }
-            }
-        }
-    }
 }

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

@@ -160,6 +160,4 @@ impl crate::engine::EngineManager for EngineConnection {
             })),
         }
     }
-
-    async fn close(&self) {}
 }

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

@@ -267,7 +267,4 @@ impl crate::engine::EngineManager for EngineConnection {
 
         Ok(ws_result)
     }
-
-    // maybe we can actually impl this here? not sure how atm.
-    async fn close(&self) {}
 }

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

@@ -600,9 +600,6 @@ pub trait EngineManager: std::fmt::Debug + Send + Sync + 'static {
     fn get_session_data(&self) -> Option<ModelingSessionData> {
         None
     }
-
-    /// Close the engine connection and wait for it to finish.
-    async fn close(&self);
 }
 
 #[derive(Debug, Hash, Eq, Clone, Deserialize, Serialize, PartialEq, ts_rs::TS, JsonSchema)]

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

@@ -2013,13 +2013,10 @@ impl ExecutorContext {
         // AND if we aren't in wasm it doesn't really matter.
         Ok(())
     }
-    /// Given an old ast, old program memory and new ast, find the parts of the code that need to be
-    /// re-executed.
-    /// This function should never error, because in the case of any internal error, we should just pop
-    /// the cache.
-    ///
-    /// Returns `None` when there are no changes to the program, i.e. it is
-    /// fully cached.
+    // Given an old ast, old program memory and new ast, find the parts of the code that need to be
+    // re-executed.
+    // This function should never error, because in the case of any internal error, we should just pop
+    // the cache.
     pub async fn get_changed_program(&self, info: CacheInformation) -> Option<CacheResult> {
         let Some(old) = info.old else {
             // We have no old info, we need to re-execute the whole thing.
@@ -2140,7 +2137,7 @@ impl ExecutorContext {
                 }
             }
             std::cmp::Ordering::Equal => {
-                // currently unreachable, but let's pretend like the code
+                // currently unreachable, but lets pretend like the code
                 // above can do something meaningful here for when we get
                 // to diffing and yanking chunks of the program apart.
 
@@ -2239,10 +2236,7 @@ impl ExecutorContext {
                 )
             })?;
         // Move the artifact commands to simplify cache management.
-        exec_state
-            .global
-            .artifact_commands
-            .extend(self.engine.take_artifact_commands());
+        exec_state.global.artifact_commands = self.engine.take_artifact_commands();
         let session_data = self.engine.get_session_data();
         Ok(session_data)
     }
@@ -2632,10 +2626,6 @@ impl ExecutorContext {
 
         self.prepare_snapshot().await
     }
-
-    pub async fn close(&self) {
-        self.engine.close().await;
-    }
 }
 
 /// For each argument given,

src/wasm-lib/kcl/src/test_server.rs

@@ -25,12 +25,10 @@ pub async fn execute_and_snapshot(
 ) -> Result<image::DynamicImage, ExecError> {
     let ctx = new_context(units, true, project_directory).await?;
     let program = Program::parse_no_errs(code).map_err(KclErrorWithOutputs::no_outputs)?;
-    let res = do_execute_and_snapshot(&ctx, program)
+    do_execute_and_snapshot(&ctx, program)
         .await
         .map(|(_state, snap)| snap)
-        .map_err(|err| err.error);
-    ctx.close().await;
-    res
+        .map_err(|err| err.error)
 }
 
 /// Executes a kcl program and takes a snapshot of the result.
@@ -41,16 +39,14 @@ pub async fn execute_and_snapshot_ast(
     project_directory: Option<PathBuf>,
 ) -> Result<(ProgramMemory, Vec<Operation>, Vec<ArtifactCommand>, image::DynamicImage), ExecErrorWithState> {
     let ctx = new_context(units, true, project_directory).await?;
-    let res = do_execute_and_snapshot(&ctx, ast).await.map(|(state, snap)| {
+    do_execute_and_snapshot(&ctx, ast).await.map(|(state, snap)| {
         (
             state.mod_local.memory,
             state.mod_local.operations,
             state.global.artifact_commands,
             snap,
         )
-    });
-    ctx.close().await;
-    res
+    })
 }
 
 pub async fn execute_and_snapshot_no_auth(
@@ -60,12 +56,10 @@ pub async fn execute_and_snapshot_no_auth(
 ) -> Result<image::DynamicImage, ExecError> {
     let ctx = new_context(units, false, project_directory).await?;
     let program = Program::parse_no_errs(code).map_err(KclErrorWithOutputs::no_outputs)?;
-    let res = do_execute_and_snapshot(&ctx, program)
+    do_execute_and_snapshot(&ctx, program)
         .await
         .map(|(_state, snap)| snap)
-        .map_err(|err| err.error);
-    ctx.close().await;
-    res
+        .map_err(|err| err.error)
 }
 
 async fn do_execute_and_snapshot(
@@ -86,9 +80,6 @@ async fn do_execute_and_snapshot(
         .map_err(|e| ExecError::BadPng(e.to_string()))
         .and_then(|x| x.decode().map_err(|e| ExecError::BadPng(e.to_string())))
         .map_err(|err| ExecErrorWithState::new(err, exec_state.clone()))?;
-
-    ctx.close().await;
-
     Ok((exec_state, img))
 }
 

src/wasm-lib/tests/executor/cache.rs

@@ -1,18 +1,14 @@
 //! Cache testing framework.
 
 use anyhow::Result;
-use kcl_lib::{ExecError, ExecState};
+use kcl_lib::ExecError;
 
-#[derive(Debug)]
 struct Variation<'a> {
     code: &'a str,
     settings: &'a kcl_lib::ExecutorSettings,
 }
 
-async fn cache_test(
-    test_name: &str,
-    variations: Vec<Variation<'_>>,
-) -> Result<Vec<(String, image::DynamicImage, ExecState)>> {
+async fn cache_test(test_name: &str, variations: Vec<Variation<'_>>) -> Result<Vec<(String, image::DynamicImage)>> {
     let first = variations
         .first()
         .ok_or_else(|| anyhow::anyhow!("No variations provided for test '{}'", test_name))?;
@@ -46,7 +42,7 @@ async fn cache_test(
         // Save the snapshot.
         let path = crate::assert_out(&format!("cache_{}_{}", test_name, index), &img);
 
-        img_results.push((path, img, exec_state.clone()));
+        img_results.push((path, img));
 
         // Prepare the last state.
         old_ast_state = Some(kcl_lib::OldAstState {
@@ -56,8 +52,6 @@ async fn cache_test(
         });
     }
 
-    ctx.close().await;
-
     Ok(img_results)
 }
 
@@ -220,47 +214,3 @@ async fn kcl_test_cache_change_highlight_edges_changes_visual() {
 
     assert!(first.1 != second.1);
 }
-
-#[tokio::test(flavor = "multi_thread")]
-async fn kcl_test_cache_add_line_preserves_artifact_commands() {
-    let code = r#"sketch001 = startSketchOn('XY')
-  |> startProfileAt([5.5229, 5.25217], %)
-  |> line([10.50433, -1.19122], %)
-  |> line([8.01362, -5.48731], %)
-  |> line([-1.02877, -6.76825], %)
-  |> line([-11.53311, 2.81559], %)
-  |> close(%)
-"#;
-    // Use a new statement; don't extend the prior pipeline.  This allows us to
-    // detect a prefix.
-    let code_with_extrude = code.to_owned()
-        + r#"
-extrude(4, sketch001)
-"#;
-
-    let result = cache_test(
-        "add_line_preserves_artifact_commands",
-        vec![
-            Variation {
-                code,
-                settings: &Default::default(),
-            },
-            Variation {
-                code: code_with_extrude.as_str(),
-                settings: &Default::default(),
-            },
-        ],
-    )
-    .await
-    .unwrap();
-
-    let first = result.first().unwrap();
-    let second = result.last().unwrap();
-
-    assert!(
-        first.2.global.artifact_commands.len() < second.2.global.artifact_commands.len(),
-        "Second should have all the artifact commands of the first, plus more. first={:?}, second={:?}",
-        first.2.global.artifact_commands.len(),
-        second.2.global.artifact_commands.len()
-    );
-}