Fix so that all artifact commands are returned regardless of caching (#5005)

* Fix so that all artifact commands are returned regardless of caching

* Add some more docs and fix up old ones

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

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

e2e/playwright/point-click.spec.ts

@@ -756,6 +756,17 @@ test(`Offset plane point-and-click`, async ({
     })
     await scene.expectPixelColor([74, 74, 74], testPoint, 15)
   })
+
+  await test.step('Delete offset plane via feature tree selection', async () => {
+    await editor.closePane()
+    const operationButton = await toolbar.getFeatureTreeOperation(
+      'Offset Plane',
+      0
+    )
+    await operationButton.click({ button: 'left' })
+    await page.keyboard.press('Backspace')
+    await scene.expectPixelColor([50, 51, 96], testPoint, 15)
+  })
 })
 
 const loftPointAndClickCases = [
@@ -851,6 +862,75 @@ loftPointAndClickCases.forEach(({ shouldPreselect }) => {
       })
       await scene.expectPixelColor([89, 89, 89], testPoint, 15)
     })
+
+    await test.step('Delete loft via feature tree selection', async () => {
+      await editor.closePane()
+      const operationButton = await toolbar.getFeatureTreeOperation('Loft', 0)
+      await operationButton.click({ button: 'left' })
+      await page.keyboard.press('Backspace')
+      await scene.expectPixelColor([254, 254, 254], testPoint, 15)
+    })
+  })
+})
+
+// TODO: merge with above test. Right now we're not able to delete a loft
+// right after creation via selection for some reason, so we go with a new instance
+test('Loft and offset plane deletion via selection', async ({
+  context,
+  page,
+  homePage,
+  scene,
+}) => {
+  const initialCode = `sketch001 = startSketchOn('XZ')
+  |> circle({ center = [0, 0], radius = 30 }, %)
+  plane001 = offsetPlane('XZ', 50)
+  sketch002 = startSketchOn(plane001)
+  |> circle({ center = [0, 0], radius = 20 }, %)
+loft001 = loft([sketch001, sketch002])
+`
+  await context.addInitScript((initialCode) => {
+    localStorage.setItem('persistCode', initialCode)
+  }, initialCode)
+  await page.setBodyDimensions({ width: 1000, height: 500 })
+  await homePage.goToModelingScene()
+
+  // One dumb hardcoded screen pixel value
+  const testPoint = { x: 575, y: 200 }
+  const [clickOnSketch1] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
+  const [clickOnSketch2] = scene.makeMouseHelpers(testPoint.x, testPoint.y + 80)
+
+  await test.step(`Delete loft`, async () => {
+    // Check for loft
+    await scene.expectPixelColor([89, 89, 89], testPoint, 15)
+    await clickOnSketch1()
+    await expect(page.locator('.cm-activeLine')).toHaveText(`
+      |> circle({ center = [0, 0], radius = 30 }, %)
+    `)
+    await page.keyboard.press('Backspace')
+    // Check for sketch 1
+    await scene.expectPixelColor([254, 254, 254], testPoint, 15)
+  })
+
+  await test.step('Delete sketch002', async () => {
+    await page.waitForTimeout(1000)
+    await clickOnSketch2()
+    await expect(page.locator('.cm-activeLine')).toHaveText(`
+      |> circle({ center = [0, 0], radius = 20 }, %)
+    `)
+    await page.keyboard.press('Backspace')
+    // Check for plane001
+    await scene.expectPixelColor([228, 228, 228], testPoint, 15)
+  })
+
+  await test.step('Delete plane001', async () => {
+    await page.waitForTimeout(1000)
+    await clickOnSketch2()
+    await expect(page.locator('.cm-activeLine')).toHaveText(`
+      plane001 = offsetPlane('XZ', 50)
+    `)
+    await page.keyboard.press('Backspace')
+    // Check for sketch 1
+    await scene.expectPixelColor([254, 254, 254], testPoint, 15)
   })
 })
 
@@ -1030,4 +1110,104 @@ extrude001 = extrude(40, sketch001)
     })
     await scene.expectPixelColor([49, 49, 49], testPoint, 15)
   })
+
+  await test.step('Delete shell via feature tree selection', async () => {
+    await editor.closePane()
+    const operationButton = await toolbar.getFeatureTreeOperation('Shell', 0)
+    await operationButton.click({ button: 'left' })
+    await page.keyboard.press('Backspace')
+    await scene.expectPixelColor([99, 99, 99], testPoint, 15)
+  })
+})
+
+const shellSketchOnFacesCases = [
+  `sketch001 = startSketchOn('XZ')
+  |> circle({ center = [0, 0], radius = 100 }, %)
+  |> extrude(100, %)
+
+sketch002 = startSketchOn(sketch001, 'END')
+  |> circle({ center = [0, 0], radius = 50 }, %)
+  |> extrude(50, %)
+  `,
+  `sketch001 = startSketchOn('XZ')
+  |> circle({ center = [0, 0], radius = 100 }, %)
+extrude001 = extrude(100, sketch001)
+
+sketch002 = startSketchOn(extrude001, 'END')
+  |> circle({ center = [0, 0], radius = 50 }, %)
+extrude002 = extrude(50, sketch002)
+  `,
+]
+shellSketchOnFacesCases.forEach((initialCode, index) => {
+  const hasExtrudesInPipe = index === 0
+  test(`Shell point-and-click sketch on face (extrudes in pipes: ${hasExtrudesInPipe})`, async ({
+    context,
+    page,
+    homePage,
+    scene,
+    editor,
+    toolbar,
+    cmdBar,
+  }) => {
+    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: 550, y: 295 }
+    const [clickOnCap] = scene.makeMouseHelpers(testPoint.x, testPoint.y)
+    const shellDeclaration = `shell001 = shell({ faces = ['end'], thickness = 5 }, ${
+      hasExtrudesInPipe ? 'sketch002' : 'extrude002'
+    })`
+
+    await test.step(`Look for the grey of the shape`, async () => {
+      await toolbar.closePane('code')
+      await scene.expectPixelColor([128, 128, 128], testPoint, 15)
+    })
+
+    await test.step(`Go through the command bar flow, selecting a cap and keeping default thickness`, async () => {
+      await toolbar.shellButton.click()
+      await cmdBar.expectState({
+        stage: 'arguments',
+        currentArgKey: 'selection',
+        currentArgValue: '',
+        headerArguments: {
+          Selection: '',
+          Thickness: '',
+        },
+        highlightedHeaderArg: 'selection',
+        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: {
+          Selection: '1 cap',
+          Thickness: '5',
+        },
+        commandName: 'Shell',
+      })
+      await cmdBar.progressCmdBar()
+    })
+
+    await test.step(`Confirm code is added to the editor, scene has changed`, async () => {
+      await toolbar.openPane('code')
+      await editor.expectEditor.toContain(shellDeclaration)
+      await editor.expectState({
+        diagnostics: [],
+        activeLines: [shellDeclaration],
+        highlightedCode: '',
+      })
+      await toolbar.closePane('code')
+      await scene.expectPixelColor([73, 73, 73], testPoint, 15)
+    })
+  })
 })

flake.lock

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

package.json

@@ -26,7 +26,7 @@
     "@fortawesome/react-fontawesome": "^0.2.0",
     "@headlessui/react": "^1.7.19",
     "@headlessui/tailwindcss": "^0.2.0",
-    "@kittycad/lib": "2.0.12",
+    "@kittycad/lib": "2.0.13",
     "@lezer/highlight": "^1.2.1",
     "@lezer/lr": "^1.4.1",
     "@react-hook/resize-observer": "^2.0.1",

playwright.electron.config.ts

@@ -32,10 +32,9 @@ export default defineConfig({
   },
   projects: [
     {
-      name: 'Google Chrome',
+      name: 'chromium',
       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

@@ -271,6 +271,7 @@ export const ModelingMachineProvider = ({
               cmd_id: uuidv4(),
               cmd: {
                 type: 'default_camera_center_to_selection',
+                camera_movement: 'vantage',
               },
             })
             .catch(reportRejection)

src/lang/modifyAst.ts

@@ -1149,11 +1149,17 @@ export async function deleteFromSelection(
     ((selection?.artifact?.type === 'wall' ||
       selection?.artifact?.type === 'cap') &&
       varDec.node.init.type === 'PipeExpression') ||
-    selection.artifact?.type === 'sweep'
+    selection.artifact?.type === 'sweep' ||
+    selection.artifact?.type === 'plane' ||
+    !selection.artifact // aka expected to be a shell at this point
   ) {
     let extrudeNameToDelete = ''
     let pathToNode: PathToNode | null = null
-    if (selection.artifact?.type !== 'sweep') {
+    if (
+      selection.artifact &&
+      selection.artifact.type !== 'sweep' &&
+      selection.artifact.type !== 'plane'
+    ) {
       const varDecName = varDec.node.id.name
       traverse(astClone, {
         enter: (node, path) => {
@@ -1169,6 +1175,17 @@ export async function deleteFromSelection(
               pathToNode = path
               extrudeNameToDelete = dec.id.name
             }
+            if (
+              dec.init.type === 'CallExpression' &&
+              dec.init.callee.name === 'loft' &&
+              dec.init.arguments?.[0].type === 'ArrayExpression' &&
+              dec.init.arguments?.[0].elements.some(
+                (a) => a.type === 'Identifier' && a.name === varDecName
+              )
+            ) {
+              pathToNode = path
+              extrudeNameToDelete = dec.id.name
+            }
           }
         },
       })

src/lang/modifyAst/addRevolve.ts

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

src/lang/modifyAst/addShell.ts

@@ -49,17 +49,27 @@ export function addShell({
       return new Error("Couldn't find extrude")
     }
 
-    pathToExtrudeNode = extrudeLookupResult.pathToExtrudeNode
-    // Get the sketch ref from the selection
     // TODO: this assumes the segment is piped directly from the sketch, with no intermediate `VariableDeclarator` between.
     // We must find a technique for these situations that is robust to intermediate declarations
-    const sketchNode = getNodeFromPath<VariableDeclarator>(
+    const extrudeNode = getNodeFromPath<VariableDeclarator>(
       modifiedAst,
-      graphSelection.codeRef.pathToNode,
+      extrudeLookupResult.pathToExtrudeNode,
       'VariableDeclarator'
     )
-    if (err(sketchNode)) {
+    const segmentNode = getNodeFromPath<VariableDeclarator>(
-      return sketchNode
+      modifiedAst,
+      extrudeLookupResult.pathToSegmentNode,
+      'VariableDeclarator'
+    )
+    if (err(extrudeNode) || err(segmentNode)) {
+      return new Error("Couldn't find extrude")
+    }
+    if (extrudeNode.node.init.type === 'CallExpression') {
+      pathToExtrudeNode = extrudeLookupResult.pathToExtrudeNode
+    } else if (segmentNode.node.init.type === 'PipeExpression') {
+      pathToExtrudeNode = extrudeLookupResult.pathToSegmentNode
+    } else {
+      return new Error("Couldn't find extrude")
     }
 
     const selectedArtifact = graphSelection.artifact

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'
+  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'
+  subType: 'extrusion' | 'revolve' | 'loft'
   path: PathArtifact
   surfaces: Array<WallArtifact | CapArtifact>
   edges: Array<SweepEdge>
@@ -398,6 +398,33 @@ export function getArtifactsToUpdate({
         artifact: { ...path, sweepId: id },
       })
     return returnArr
+  } else if (
+    cmd.type === 'loft' &&
+    response.type === 'modeling' &&
+    response.data.modeling_response.type === 'loft'
+  ) {
+    returnArr.push({
+      id,
+      artifact: {
+        type: 'sweep',
+        subType: 'loft',
+        id,
+        // TODO: make sure to revisit this choice, don't think it matters for now
+        pathId: cmd.section_ids[0],
+        surfaceIds: [],
+        edgeIds: [],
+        codeRef: { range, pathToNode },
+      },
+    })
+    for (const sectionId of cmd.section_ids) {
+      const path = getArtifact(sectionId)
+      if (path?.type === 'path')
+        returnArr.push({
+          id: sectionId,
+          artifact: { ...path, sweepId: id },
+        })
+    }
+    return returnArr
   } else if (
     cmd.type === 'solid3d_get_extrusion_face_info' &&
     response?.type === 'modeling' &&

src/lib/commandBarConfigs/modelingCommandConfig.ts

@@ -47,7 +47,9 @@ export type ModelingCommandSchema = {
   Revolve: {
     selection: Selections
     angle: KclCommandValue
-    axis: Selections
+    axisOrEdge: string
+    axis: string
+    edge: Selections
   }
   Fillet: {
     // todo
@@ -324,10 +326,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: {
@@ -336,9 +338,34 @@ 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: true,
+        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
+          ),
         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.axis.graphSelections[0].artifact?.id
+  let edgeSelection = data.edge.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 axis'
+    return 'Unable to revolve with selected edge'
   }
 }
 

src/lib/createMachineCommand.ts

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

src/lib/toolbar.ts

@@ -8,6 +8,7 @@ import {
   modelingMachine,
   pipeHasCircle,
 } from 'machines/modelingMachine'
+import { IS_NIGHTLY_OR_DEBUG } from 'routes/Settings'
 import { EventFrom, StateFrom } from 'xstate'
 
 export type ToolbarModeName = 'modeling' | 'sketching'
@@ -103,7 +104,7 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
             data: { name: 'Revolve', groupId: 'modeling' },
           }),
         icon: 'revolve',
-        status: DEV ? 'available' : 'kcl-only',
+        status: DEV || IS_NIGHTLY_OR_DEBUG ? 'available' : 'kcl-only',
         title: 'Revolve',
         hotkey: 'R',
         description:
@@ -161,7 +162,7 @@ export const toolbarConfig: Record<ToolbarModeName, ToolbarMode> = {
             data: { name: 'Fillet', groupId: 'modeling' },
           }),
         icon: 'fillet3d',
-        status: DEV ? 'available' : 'kcl-only',
+        status: DEV || IS_NIGHTLY_OR_DEBUG ? 'available' : 'kcl-only',
         title: 'Fillet',
         hotkey: 'F',
         description: 'Round the edges of a 3D solid.',

src/machines/modelingMachine.ts

@@ -685,7 +685,7 @@ export const modelingMachine = setup({
       if (event.type !== 'Revolve') return
       ;(async () => {
         if (!event.data) return
-        const { selection, angle, axis } = event.data
+        const { selection, angle, axis, edge, axisOrEdge } = event.data
         let ast = kclManager.ast
         if (
           'variableName' in angle &&
@@ -710,7 +710,9 @@ export const modelingMachine = setup({
           'variableName' in angle
             ? angle.variableIdentifierAst
             : angle.valueAst,
-          axis
+          axisOrEdge,
+          axis,
+          edge
         )
         if (trap(revolveSketchRes)) return
         const { modifiedAst, pathToRevolveArg } = revolveSketchRes

src/routes/Onboarding/Export.tsx

@@ -41,13 +41,13 @@ export default function Export() {
             export to almost any CAD software.
           </p>
           <p className="my-4">
-            Our teammate David is working on the file format, check out{' '}
+            Our teammate Katie is working on the file format, check out{' '}
             <a
-              href="https://www.youtube.com/watch?v=8SuW0qkYCZo"
+              href="https://github.com/KhronosGroup/glTF/pull/2343"
               target="_blank"
               rel="noreferrer noopener"
             >
-              his talk with the Metaverse Standards Forum
+              her standards proposal on GitHub
             </a>
             !
           </p>

src/routes/Settings.tsx

@@ -32,6 +32,8 @@ 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,4 +502,6 @@ impl kcl_lib::EngineManager for EngineConnection {
             })),
         }
     }
+
+    async fn close(&self) {}
 }

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

@@ -37,9 +37,10 @@ enum SocketHealth {
 }
 
 type WebSocketTcpWrite = futures::stream::SplitSink<tokio_tungstenite::WebSocketStream<reqwest::Upgraded>, WsMsg>;
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 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)]
@@ -130,21 +131,49 @@ 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>) {
+    async fn start_write_actor(
-        while let Some(req) = engine_req_rx.recv().await {
+        mut tcp_write: WebSocketTcpWrite,
-            let ToEngineReq { req, request_sent } = req;
+        mut engine_req_rx: mpsc::Receiver<ToEngineReq>,
-            let res = if let WebSocketRequest::ModelingCmdReq(ModelingCmdReq {
+        mut shutdown_rx: mpsc::Receiver<()>,
-                cmd: ModelingCmd::ImportFiles { .. },
+    ) {
-                cmd_id: _,
+        loop {
-            }) = &req
+            tokio::select! {
-            {
+                maybe_req = engine_req_rx.recv() => {
-                // Send it as binary.
+                    match maybe_req {
-                Self::inner_send_to_engine_binary(req, &mut tcp_write).await
+                        Some(ToEngineReq { req, request_sent }) => {
-            } else {
+                            // Decide whether to send as binary or text,
-                Self::inner_send_to_engine(req, &mut tcp_write).await
+                            // then send to the engine.
-            };
+                            let res = if let WebSocketRequest::ModelingCmdReq(ModelingCmdReq {
-            let _ = request_sent.send(res);
+                                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;
+                }
+            }
         }
+
+        // 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;
     }
 
@@ -194,7 +223,8 @@ impl EngineConnection {
 
         let (tcp_write, tcp_read) = ws_stream.split();
         let (engine_req_tx, engine_req_rx) = mpsc::channel(10);
-        tokio::task::spawn(Self::start_write_actor(tcp_write, engine_req_rx));
+        let (shutdown_tx, shutdown_rx) = mpsc::channel(1);
+        tokio::task::spawn(Self::start_write_actor(tcp_write, engine_req_rx, shutdown_rx));
 
         let mut tcp_read = TcpRead { stream: tcp_read };
 
@@ -304,6 +334,7 @@ impl EngineConnection {
 
         Ok(EngineConnection {
             engine_req_tx,
+            shutdown_tx,
             tcp_read_handle: Arc::new(TcpReadHandle {
                 handle: Arc::new(tcp_read_handle),
             }),
@@ -484,4 +515,15 @@ 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,4 +160,6 @@ impl crate::engine::EngineManager for EngineConnection {
             })),
         }
     }
+
+    async fn close(&self) {}
 }

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

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

src/wasm-lib/kcl/src/std/loft.rs

@@ -156,5 +156,8 @@ async fn inner_loft(
     .await?;
 
     // Using the first sketch as the base curve, idk we might want to change this later.
-    do_post_extrude(sketches[0].clone(), 0.0, exec_state, args).await
+    let mut sketch = sketches[0].clone();
+    // Override its id with the loft id so we can get its faces later
+    sketch.id = id;
+    do_post_extrude(sketch, 0.0, exec_state, args).await
 }

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

@@ -25,10 +25,12 @@ 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)?;
-    do_execute_and_snapshot(&ctx, program)
+    let res = do_execute_and_snapshot(&ctx, program)
         .await
         .map(|(_state, snap)| snap)
-        .map_err(|err| err.error)
+        .map_err(|err| err.error);
+    ctx.close().await;
+    res
 }
 
 /// Executes a kcl program and takes a snapshot of the result.
@@ -39,14 +41,16 @@ 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?;
-    do_execute_and_snapshot(&ctx, ast).await.map(|(state, snap)| {
+    let res = 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(
@@ -56,10 +60,12 @@ 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)?;
-    do_execute_and_snapshot(&ctx, program)
+    let res = do_execute_and_snapshot(&ctx, program)
         .await
         .map(|(_state, snap)| snap)
-        .map_err(|err| err.error)
+        .map_err(|err| err.error);
+    ctx.close().await;
+    res
 }
 
 async fn do_execute_and_snapshot(
@@ -80,6 +86,9 @@ 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,14 +1,18 @@
 //! Cache testing framework.
 
 use anyhow::Result;
-use kcl_lib::ExecError;
+use kcl_lib::{ExecError, ExecState};
 
+#[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)>> {
+async fn cache_test(
+    test_name: &str,
+    variations: Vec<Variation<'_>>,
+) -> Result<Vec<(String, image::DynamicImage, ExecState)>> {
     let first = variations
         .first()
         .ok_or_else(|| anyhow::anyhow!("No variations provided for test '{}'", test_name))?;
@@ -42,7 +46,7 @@ async fn cache_test(test_name: &str, variations: Vec<Variation<'_>>) -> Result<V
         // Save the snapshot.
         let path = crate::assert_out(&format!("cache_{}_{}", test_name, index), &img);
 
-        img_results.push((path, img));
+        img_results.push((path, img, exec_state.clone()));
 
         // Prepare the last state.
         old_ast_state = Some(kcl_lib::OldAstState {
@@ -52,6 +56,8 @@ async fn cache_test(test_name: &str, variations: Vec<Variation<'_>>) -> Result<V
         });
     }
 
+    ctx.close().await;
+
     Ok(img_results)
 }
 
@@ -214,3 +220,47 @@ 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()
+    );
+}

yarn.lock

@@ -2010,10 +2010,10 @@
     "@jridgewell/resolve-uri" "^3.1.0"
     "@jridgewell/sourcemap-codec" "^1.4.14"
 
-"@kittycad/lib@2.0.12":
+"@kittycad/lib@2.0.13":
-  version "2.0.12"
+  version "2.0.13"
-  resolved "https://registry.yarnpkg.com/@kittycad/lib/-/lib-2.0.12.tgz#517be58ee8b5f59e5c89bb5076492c960b4ef7d8"
+  resolved "https://registry.yarnpkg.com/@kittycad/lib/-/lib-2.0.13.tgz#e20aa17847ab1359065d21bed143ea330cf545d1"
-  integrity sha512-1eXIP+JbFvWSWQe//ijBuhlnCLRUnZzNAiOf7oMI0WcRTTn8SD8A+TY+NgK6OVGG12unyTPCVXxRR4Xtm3ahLQ==
+  integrity sha512-wLn6/iRVdqbRCvf6t2FhNr8No6+I6elpCEVHGUexyHLoE+1XeUS1lHeapQqcfR0pEQiwtGpcKTDfUNSlmnmaFw==
   dependencies:
     openapi-types "^12.0.0"
     ts-node "^10.9.1"