From d8229ae5228e6111cbf41891dc89a45f67cc7f25 Mon Sep 17 00:00:00 2001
From: Dimitris Zervas <dzervas@dzervas.gr>
Date: Fri, 14 Jun 2024 07:49:43 +0300
Subject: [PATCH] Fix the damn line

Signed-off-by: Dimitris Zervas <dzervas@dzervas.gr>
---
 applications/web/src/components/Arc.svelte    | 11 ++--
 applications/web/src/components/Circle.svelte |  7 ++-
 applications/web/src/components/Line.svelte   | 18 ++----
 .../web/src/components/PassiveSketch.svelte   | 62 ++++++++++---------
 .../web/src/components/Point2D.svelte         |  2 +-
 applications/web/src/components/Scene.svelte  |  6 +-
 applications/web/src/components/Sketch.svelte |  2 -
 .../web/src/components/tools/NewCircle.svelte | 19 +++---
 .../web/src/components/tools/NewLine.svelte   | 60 ++++++++----------
 .../src/components/tools/NewRectangle.svelte  |  5 +-
 packages/cadmium/src/message/idwrap/mod.rs    |  3 +-
 packages/shared/projectUtils.ts               |  2 +
 packages/shared/stepTypeGuards.ts             | 20 +++---
 packages/shared/stores.ts                     |  6 +-
 packages/shared/types.d.ts                    | 12 ++--
 15 files changed, 115 insertions(+), 120 deletions(-)

diff --git a/applications/web/src/components/Arc.svelte b/applications/web/src/components/Arc.svelte
index 4836260c..92caafbd 100644
--- a/applications/web/src/components/Arc.svelte
+++ b/applications/web/src/components/Arc.svelte
@@ -5,15 +5,16 @@
   import {T} from "@threlte/core"
   import {flatten, arcToPoints, promoteTo3} from "shared/projectUtils"
   import {currentlySelected, currentlyMousedOver, sketchTool} from "shared/stores"
-  import type {EntityType, SketchPoint} from "shared/types"
+  import type {EntityType} from "shared/types"
   import {isEntity} from "shared/typeGuards"
+  import type { Point2 } from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[Arc.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
   const type: EntityType = "arc"
 
-  export let id: string, center: SketchPoint, start: SketchPoint, end: SketchPoint
+  export let id: string, center: Point2, start: Point2, end: Point2
 
   export let dashedLineMaterial: LineMaterial,
     dashedHoveredMaterial: LineMaterial,
@@ -26,9 +27,9 @@
 
   $: selected = $currentlySelected.some(e => isEntity(e) && e.id === id && e.type === type) ? true : false
 
-  const center2 = new Vector2(center.twoD.x, center.twoD.y)
-  const start2 = new Vector2(start.twoD.x, start.twoD.y)
-  const end2 = new Vector2(end.twoD.x, end.twoD.y)
+  const center2 = new Vector2(center.x, center.y)
+  const start2 = new Vector2(start.x, start.y)
+  const end2 = new Vector2(end.x, end.y)
 
   const points = flatten(promoteTo3(arcToPoints(center2, start2, end2 /** implicit false */))) // defaulted false in function todo ask Matt
 
diff --git a/applications/web/src/components/Circle.svelte b/applications/web/src/components/Circle.svelte
index 7ddf02df..00cfcdde 100644
--- a/applications/web/src/components/Circle.svelte
+++ b/applications/web/src/components/Circle.svelte
@@ -4,14 +4,15 @@
   import {T} from "@threlte/core"
   import {flatten, circleToPoints, promoteTo3} from "shared/projectUtils"
   import {currentlySelected, currentlyMousedOver, sketchTool} from "shared/stores"
-  import type {CircleTuple, EntityType} from "shared/types"
+  import type {EntityType} from "shared/types"
+  import type { Point2 } from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[Circle.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
   const type: EntityType = "circle"
 
-  export let id: string, center: CircleTuple["center"], radius: number
+  export let id: string, center: Point2, radius: number
 
   // log("[props]", "id:", id, "center:", center, "radius:", radius)
 
@@ -26,7 +27,7 @@
   $: selected = $currentlySelected.some(e => e.id === id && e.type === type) ? true : false
 
   // array of x,y,z points
-  const points = flatten(promoteTo3(circleToPoints(center.twoD, radius)))
+  const points = flatten(promoteTo3(circleToPoints(center, radius)))
 
   const lineGeometry = new LineGeometry()
   lineGeometry.setPositions(points)
diff --git a/applications/web/src/components/Line.svelte b/applications/web/src/components/Line.svelte
index 38e216f4..8edd368d 100644
--- a/applications/web/src/components/Line.svelte
+++ b/applications/web/src/components/Line.svelte
@@ -5,13 +5,14 @@
   import {T} from "@threlte/core"
   import {flatten, promoteTo3} from "shared/projectUtils"
   import {currentlySelected, currentlyMousedOver, sketchTool} from "shared/stores"
-  import type {EntityType, PointById} from "shared/types"
+  import type {EntityType} from "shared/types"
   import {isEntity} from "shared/typeGuards"
+  import type { Point2 } from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[Line.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
-  export let id: string, start: PointById, end: PointById
+  export let id: string, start: Point2, end: Point2
 
   export let dashedLineMaterial: LineMaterial,
     dashedHoveredMaterial: LineMaterial,
@@ -23,19 +24,10 @@
   const type: EntityType = "line"
 
   let hovered = false
-  $: selected = $currentlySelected.some(e => checkIsEntity(e) && e.id === id && e.type === type) ? true : false
-
-  function checkIsEntity(e: unknown) {
-    // log("[checkIsEntity]", isEntity(e), e)
-    return isEntity(e)
-  }
-
-  // $: selected, log("[selected] an entity has been selected:", selected, "Line.id:", id)
-  // prettier-ignore
-  // $: $currentlySelected, ()=> {if (selected && !$currentlySelected.every((e) => isEntity(e))) log("ERROR [currentlySelected] are not all isEntity", $currentlySelected)}
+  $: selected = $currentlySelected.some(e => isEntity(e) && e.id === id && e.type === type) ? true : false
 
   const points = flatten(
-		promoteTo3([new Vector2(start.twoD.x, start.twoD.y), new Vector2(end.twoD.x, end.twoD.y)])
+		promoteTo3([new Vector2(start.x, start.y), new Vector2(end.x, end.y)])
 	)
 
   const lineGeometry = new LineGeometry()
diff --git a/applications/web/src/components/PassiveSketch.svelte b/applications/web/src/components/PassiveSketch.svelte
index 216dafab..6f60e282 100644
--- a/applications/web/src/components/PassiveSketch.svelte
+++ b/applications/web/src/components/PassiveSketch.svelte
@@ -1,31 +1,34 @@
 <script lang="ts">
-  import {Matrix4, Euler, MeshStandardMaterial, Vector2, Vector3} from "three"
-  import {T, useThrelte} from "@threlte/core"
-  import {Text, Suspense} from "@threlte/extras"
-  import {hiddenSketches, previewGeometry, sketchTool, workbench} from "shared/stores"
   import Point2D from "./Point2D.svelte"
   import Line from "./Line.svelte"
   import Circle from "./Circle.svelte"
   import Arc from "./Arc.svelte"
-  import Face from "./Face.svelte"
-  import {LineMaterial} from "three/addons/lines/LineMaterial.js"
-  import {LineGeometry} from "three/addons/lines/LineGeometry.js"
+  // import Face from "./Face.svelte"
+
   import NewLineTool from "./tools/NewLine.svelte"
   import NewCircleTool from "./tools/NewCircle.svelte"
   import NewRectangleTool from "./tools/NewRectangle.svelte"
   import SelectTool from "./tools/Select.svelte"
-  import type {FaceTuple, IDictionary, PreviewGeometry, SketchPoint} from "shared/types"
+
+  import {T, useThrelte} from "@threlte/core"
+  import {Text, Suspense} from "@threlte/extras"
+  import {Matrix4, Euler, MeshStandardMaterial, Vector2, Vector3} from "three"
+  import {LineMaterial} from "three/addons/lines/LineMaterial.js"
+  import {LineGeometry} from "three/addons/lines/LineGeometry.js"
+
   import debounce from "just-debounce-it"
-  import type {ISketch, Plane} from "cadmium"
+
   import {isSketchArcStep, isSketchCircleStep, isSketchLineStep, isSketchPointStep} from "shared/stepTypeGuards"
+  import {hiddenSketches, previewGeometry, sketchTool, workbench} from "shared/stores"
+  import type {IDictionary, PreviewGeometry} from "shared/types"
+  import type {Plane, Point2, StepHash} from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[PassiveSketch.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
   export let name: string,
-    sketch: ISketch,
     plane: Plane,
-    uniqueId: string,
+    uniqueId: StepHash,
     editing = false
 
   const {size, dpr} = useThrelte()
@@ -41,9 +44,6 @@
 
   let newLineTool: NewLineTool, newCircleTool: NewCircleTool, newRectangleTool: NewRectangleTool, selectTool: SelectTool
 
-  let faceTuples: FaceTuple[] = []
-  let pointsById: IDictionary<SketchPoint> = {}
-
   // Build some Three.js vectors from the props
   const origin_point = new Vector3(plane.origin.x, plane.origin.y, plane.origin.z)
   const primary = new Vector3(plane.primary.x, plane.primary.y, plane.primary.z)
@@ -88,7 +88,11 @@
   lineGeometry.setPositions(points)
 
   $: hidden = $hiddenSketches.includes(uniqueId) && !editing
-  // $: $hiddenSketches, log("[$hiddenSketches]", $hiddenSketches)
+  $: $hiddenSketches, log("[$hiddenSketches]", hidden)
+  $: pointsById = history.reduce((acc, step) => {
+    if (isSketchPointStep(step)) acc[step.hash] = step.result.Primitive.Point2
+    return acc
+  }, {} as IDictionary<Point2>)
 
   $: if (editing) $sketchTool = "select"
 
@@ -117,7 +121,7 @@
       on:click={e => {
         if (editing) {
           if ($sketchTool === "line") {
-            newLineTool.click(e, {twoD: projectToPlane(e.point), threeD: e.point})
+            newLineTool.click(e, projectToPlane(e.point))
           } else if ($sketchTool === "circle") {
             newCircleTool.click(e, {twoD: projectToPlane(e.point), threeD: e.point})
           } else if ($sketchTool === "rectangle") {
@@ -163,11 +167,11 @@
 
     {#each history as step}
       {#if isSketchPointStep(step)}
-        <Point2D x={step.result.Point2.x} y={step.result.Point2.y} hidden={step.result.Point2.hidden} id={step.hash} {collisionLineMaterial} />
+        <Point2D x={step.result.Primitive.Point2.x} y={step.result.Primitive.Point2.y} hidden={step.result.Primitive.Point2.hidden} id={step.hash} {collisionLineMaterial} />
       {:else if isSketchCircleStep(step)}
         <Circle
-          center={pointsById[step.result.Circle2.center]}
-          radius={step.result.Circle2.radius}
+          center={pointsById[step.result.Primitive.Circle2.center]}
+          radius={step.result.Primitive.Circle2.radius}
           id={step.hash}
           {solidLineMaterial}
           {solidHoveredMaterial}
@@ -179,7 +183,7 @@
       {:else if isSketchArcStep(step)}
         <!-- TODO: Use start & end angle instead of points -->
         <Arc
-          center={pointsById[step.result.Arc2.center]}
+          center={pointsById[step.result.Primitive.Arc2.center]}
           start={pointsById[0]}
           end={pointsById[1]}
           id={step.hash}
@@ -192,8 +196,8 @@
         />
       {:else if isSketchLineStep(step)}
         <Line
-          start={pointsById[step.result.Line2.start]}
-          end={pointsById[step.result.Line2.end]}
+          start={pointsById[step.result.Primitive.Line2.start]}
+          end={pointsById[step.result.Primitive.Line2.end]}
           id={step.hash}
           {solidLineMaterial}
           {solidHoveredMaterial}
@@ -208,8 +212,8 @@
     {#each $previewGeometry as geom (geom.uuid)}
       {#if isGeomType(geom, "line")}
         <Line
-          start={geom.start}
-          end={geom.end}
+          start={geom.start!}
+          end={geom.end!}
           id={geom.uuid}
           {solidLineMaterial}
           {solidHoveredMaterial}
@@ -220,8 +224,8 @@
         />
       {:else if isGeomType(geom, "circle")}
         <Circle
-          center={geom.center}
-          radius={geom.radius}
+          center={geom.center!}
+          radius={geom.radius!}
           id={geom.uuid}
           {solidLineMaterial}
           {solidHoveredMaterial}
@@ -231,12 +235,12 @@
           {collisionLineMaterial}
         />
       {:else if isGeomType(geom, "point")}
-        <Point2D x={geom.x} y={geom.y} hidden={false} id={geom.uuid} isPreview {collisionLineMaterial} />
+        <Point2D x={geom.x!} y={geom.y!} hidden={false} id={geom.uuid} isPreview {collisionLineMaterial} />
       {/if}
     {/each}
 
-    {#each faceTuples as face (`${faceTuples.length}-${face.id}`)}
+    <!-- {#each faceTuples as face (`${faceTuples.length}-${face.id}`)}
       <Face face={face.face} id={face.id} {pointsById} />
-    {/each}
+    {/each} -->
   </T.Group>
 {/if}
diff --git a/applications/web/src/components/Point2D.svelte b/applications/web/src/components/Point2D.svelte
index d2b43da5..9542d470 100644
--- a/applications/web/src/components/Point2D.svelte
+++ b/applications/web/src/components/Point2D.svelte
@@ -9,7 +9,7 @@
   import type {EntityType} from "shared/types"
   import {base} from "../base"
 
-  export let x, y, hidden: boolean, id: string
+  export let x: number, y: number, hidden: boolean, id: string
   export let isPreview = false
 
   export let collisionLineMaterial: LineMaterial
diff --git a/applications/web/src/components/Scene.svelte b/applications/web/src/components/Scene.svelte
index eaa915ae..1e040e45 100644
--- a/applications/web/src/components/Scene.svelte
+++ b/applications/web/src/components/Scene.svelte
@@ -128,7 +128,7 @@
 {#each history as step}
   {#if isPointStep(step)}
     <Point3D
-      id={`${step.hash}`}
+      id={step.hash}
       x={step.result.Point.x}
       y={step.result.Point.y}
       z={step.result.Point.z}
@@ -138,7 +138,7 @@
   {:else if isPlaneStep(step)}
     <Plane
       name={step.name}
-      id={`${step.hash}`}
+      id={step.hash}
       height={100}
       width={100}
       origin={step.result.Plane.origin}
@@ -148,7 +148,7 @@
     />
   {:else if isSketchStep(step)}
     <Sketch
-      uniqueId={`${step.hash}`}
+      uniqueId={step.hash}
       name={step.name}
       sketch={step.result.Sketch.sketch}
       editing={$sketchBeingEdited === step.hash}
diff --git a/applications/web/src/components/Sketch.svelte b/applications/web/src/components/Sketch.svelte
index 0a77c5b3..9dc819b6 100644
--- a/applications/web/src/components/Sketch.svelte
+++ b/applications/web/src/components/Sketch.svelte
@@ -47,7 +47,6 @@
   <PassiveSketch
     {name}
     {uniqueId}
-    sketch={sketch.sketch}
     plane={sketch.plane}
     editing
     {solidLineMaterial}
@@ -61,7 +60,6 @@
   <PassiveSketch
     {name}
     {uniqueId}
-    sketch={sketch.sketch}
     plane={sketch.plane}
     {solidLineMaterial}
     {solidHoveredMaterial}
diff --git a/applications/web/src/components/tools/NewCircle.svelte b/applications/web/src/components/tools/NewCircle.svelte
index 0df23961..7f31e907 100644
--- a/applications/web/src/components/tools/NewCircle.svelte
+++ b/applications/web/src/components/tools/NewCircle.svelte
@@ -1,29 +1,30 @@
 <script lang="ts">
   import {snapPoints, sketchTool, previewGeometry, currentlyMousedOver} from "shared/stores"
-  import {addCircleBetweenPoints, addPointToSketch, bench} from "shared/projectUtils"
+  import {bench} from "shared/projectUtils"
   import {Vector3, type Vector2Like, type Vector3Like} from "three"
-  import type {PointLikeById, Point2D, PointsLikeById, ProjectToPlane} from "shared/types"
+  import type {PointLikeById, Point2D, ProjectToPlane, IDictionary, PointById} from "shared/types"
+  import type { Point2 } from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[NewCircleTool.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
-  export let pointsById: PointsLikeById
+  export let pointsById: IDictionary<Point2>
   export let sketchId: string
   export let active: boolean
   export let projectToPlane: ProjectToPlane
 
-  let centerPoint: PointLikeById | null = null
-  let stack: PointLikeById[] = []
+  let centerPoint: Point2 | null = null
+  let stack: Point2[] = []
 
   $: if ($sketchTool !== "circle") clearStack()
 
-  function pushToStack(point: PointLikeById) {
+  function pushToStack(point: PointById) {
     if (!point) return
     point.id = point.id ?? bench.sketchAddPoint(sketchId, point.twoD.x, point.threeD.y).data
     stack.push(point)
   }
 
-  function processPoint(point: PointLikeById) {
+  function processPoint(point: PointById) {
     pushToStack(point)
     centerPoint = point
 
@@ -68,7 +69,7 @@
       }
       if (geom.type === "point") {
         const point = pointsById[geom.id]
-        if (point.twoD && point.threeD && geom.id) snappedTo = {twoD: point.twoD, threeD: point.threeD, id: geom.id}
+        if (point && geom.id) snappedTo = {point: point, id: geom.id}
         break // If there is a 2D point, prefer to use it rather than the 3D point
       }
     }
@@ -83,7 +84,7 @@
         const dy = a.y - b?.y!
         return Math.hypot(dx, dy)
       }
-      const radius = snappedTo ? calcDeltas(snappedTo.twoD, centerPoint.twoD) : calcDeltas(projected, centerPoint.twoD)
+      const radius = snappedTo ? calcDeltas(snappedTo.point!, centerPoint.twoD) : calcDeltas(projected, centerPoint.twoD)
 
       previewGeometry.set([
         {
diff --git a/applications/web/src/components/tools/NewLine.svelte b/applications/web/src/components/tools/NewLine.svelte
index b5103b90..8bda9b37 100644
--- a/applications/web/src/components/tools/NewLine.svelte
+++ b/applications/web/src/components/tools/NewLine.svelte
@@ -1,32 +1,33 @@
 <script lang="ts">
   import {snapPoints, sketchTool, previewGeometry, currentlyMousedOver} from "shared/stores"
-  import {addLineToSketch, addPointToSketch, bench} from "shared/projectUtils"
-  import {Vector3} from "three"
-  import type {IDictionary, Point, PointLikeById, PreviewGeometry, ProjectToPlane, SketchPoint} from "shared/types"
+  import {bench} from "shared/projectUtils"
+  import {Vector2, Vector3} from "three"
+  import type {IDictionary, Point2WithID, PreviewGeometry, ProjectToPlane} from "shared/types"
+  import type {Point2} from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[NewLineTool.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
-  export let pointsById: IDictionary<SketchPoint>, sketchIndex: string, active: boolean, projectToPlane: ProjectToPlane
+  export let pointsById: IDictionary<Point2>, sketchIndex: string, active: boolean, projectToPlane: ProjectToPlane
 
-  let previousPoint: PointLikeById | null = null
+  let previousPoint: Point2WithID | null = null
 
-  let stack: PointLikeById[] = []
+  let stack: Point2WithID[] = []
 
   $: if ($sketchTool !== "line") clearStack()
 
-  function pushToStack(point: PointLikeById) {
+  function pushToStack(point: Point2WithID) {
     // point should have the following properties:
     // - twoD: an object with x and y properties representing the point in 2D space
     // - threeD: an object with x, y, and z properties representing the point in 3D space
     // - id: a string representing the id of the point in the sketch
     // If the id is nullish we call addPointToSketch to create a new point in the sketch.
     if (!point) return
-    point.id = point.id ?? bench.sketchAddPoint(sketchIndex, point.twoD.x, point.twoD.y).data
+    point.id = point.id ?? bench.sketchAddPoint(sketchIndex, point.x, point.y).data
     stack.push(point)
   }
 
-  function processPoint(point: PointLikeById) {
+  function processPoint(point: Point2WithID) {
     pushToStack(point)
     previousPoint = point
 
@@ -38,75 +39,66 @@
       default:
         const endPoint = popFromStack()
         const startPoint = popFromStack()
-        addLineToSketch(sketchIndex, startPoint!.id!, endPoint!.id!)
+        bench.sketchAddLine(sketchIndex, startPoint!.id!, endPoint!.id!)
 
         // leave the current point on the stack in case we want to create another line from here
         pushToStack(point)
         // unless it's an earlier point, which means we're finished making lines, so we clear the stack
-        const isEarlierPoint = !!pointsById[point.id!]
+        const isEarlierPoint = pointsById[point.id!]
         if (isEarlierPoint) clearStack()
         break
     }
   }
 
-  export function click(_event: Event, projected: Point) {
+  export function click(_event: Event, projected: Vector2) {
     if ($snapPoints.length > 0) processPoint($snapPoints[0])
-    else processPoint({twoD: projected.twoD, threeD: projected.threeD, id: null})
+    else processPoint({x: projected.x, y: projected.y, hidden: false} as Point2WithID)
   }
 
   export function mouseMove(_event: Event, projected: {x: number; y: number}) {
     // TODO: in the future, we should also snap to the midpoints of lines
     // and to the perimeters of circles and so on
     // so these snap points do not necessarily correspond to actual points in the sketch
-    let snappedTo: PointLikeById | null = null
+    let snappedTo: Point2WithID | null = null
 
     for (const geom of $currentlyMousedOver) {
       if (geom.type === "point3D") {
         if (geom.x && geom.y && geom.z) {
           const twoD = projectToPlane(new Vector3(geom.x, geom.y, geom.z))
-          const point: PointLikeById = {
-            twoD: {x: twoD.x, y: twoD.y},
-            threeD: {x: geom.x, y: geom.y, z: geom.z},
-            id: null,
-          } satisfies PointLikeById
-          snappedTo = point
+          snappedTo = { x: twoD.x, y: twoD.y, hidden: false } as Point2WithID
         }
       }
       if (geom.type === "point") {
-        const point = pointsById[geom.id]
-        snappedTo = {
-          twoD: point.twoD,
-          threeD: point.threeD,
-          id: geom.id,
-        } satisfies PointLikeById
+        snappedTo = pointsById[geom.id]
         break // If there is a 2D point, prefer to use it rather than the 3D point
       }
     }
 
     // only reset $snapPoints if something has changed
-    if (snappedTo) $snapPoints = [snappedTo] satisfies PointLikeById[]
+    if (snappedTo) $snapPoints = [snappedTo] satisfies Point2WithID[]
     else if ($snapPoints.length > 0) $snapPoints = []
 
     if (previousPoint) {
-      let end: PointLikeById = {twoD: {x: projected.x, y: projected.y}} satisfies PointLikeById
+      let end: Point2WithID = {x: projected.x, y: projected.y, hidden: false} as Point2WithID
 
       if (snappedTo) end = snappedTo
 
       const previewGeoms = [
-        {type: "line", start: previousPoint, end: end, uuid: `line-${end.twoD!.x}-${end.twoD!.y}`},
-        {type: "point", x: end.twoD!.x, y: end.twoD!.y, uuid: `point-${end.twoD!.x}-${end.twoD!.y}`},
+        {type: "line", start: previousPoint, end: end, uuid: `line-${end.x}-${end.y}`},
+        {type: "point", x: end.x, y: end.y, uuid: `point-${end.x}-${end.y}`},
       ] satisfies PreviewGeometry[]
 
       if (previousPoint.id === null) {
         const p = {
           type: "point",
-          x: previousPoint.twoD!.x,
-          y: previousPoint.twoD!.y,
-          uuid: `point-null-${previousPoint.twoD!.x}-${previousPoint.twoD!.y}`,
+          x: previousPoint.x,
+          y: previousPoint.y,
+          uuid: `point-null-${previousPoint.x}-${previousPoint.y}`,
         } satisfies PreviewGeometry
         previewGeoms.push(p)
       }
 
+      log("[previewGeoms]", previewGeoms)
       previewGeometry.set(previewGeoms)
     } else previewGeometry.set([])
   }
@@ -126,7 +118,7 @@
     stack = []
   }
 
-  function popFromStack(): PointLikeById | undefined {
+  function popFromStack(): Point2WithID | undefined {
     return stack.pop()
   }
 </script>
diff --git a/applications/web/src/components/tools/NewRectangle.svelte b/applications/web/src/components/tools/NewRectangle.svelte
index 87dc05cb..5e2db1fd 100644
--- a/applications/web/src/components/tools/NewRectangle.svelte
+++ b/applications/web/src/components/tools/NewRectangle.svelte
@@ -2,12 +2,13 @@
   import {snapPoints, sketchTool, previewGeometry, currentlyMousedOver} from "shared/stores"
   import {addRectangleBetweenPoints, addPointToSketch} from "shared/projectUtils"
   import {Vector3} from "three"
-  import type {IDictionary, PointLikeById, ProjectToPlane, SketchPoint} from "shared/types"
+  import type {IDictionary, PointLikeById, ProjectToPlane} from "shared/types"
+  import type { Point2 } from "cadmium"
 
   // @ts-ignore
   const log = (function () { const context = "[NewRectangleTool.svelte]"; const color="gray"; return Function.prototype.bind.call(console.log, console, `%c${context}`, `font-weight:bold;color:${color};`)})() // prettier-ignore
 
-  export let pointsById: IDictionary<SketchPoint>, sketchIndex: string, active: boolean, projectToPlane: ProjectToPlane
+  export let pointsById: IDictionary<Point2>, sketchIndex: string, active: boolean, projectToPlane: ProjectToPlane
 
   let anchorPoint: PointLikeById | null = null
 
diff --git a/packages/cadmium/src/message/idwrap/mod.rs b/packages/cadmium/src/message/idwrap/mod.rs
index 8aa65532..21c09f40 100644
--- a/packages/cadmium/src/message/idwrap/mod.rs
+++ b/packages/cadmium/src/message/idwrap/mod.rs
@@ -66,8 +66,9 @@ where
         if let Some(id) = id {
             if let Some(hash) = hash {
                 crate::ID_MAP.with_borrow_mut(|m| m.insert(hash, id));
+            } else {
+                warn!("IDWrap::handle_project_message: IDWrap returned an ID, but no hash was found in the workbench history");
             }
-            warn!("IDWrap::handle_project_message: IDWrap returned an ID, but no hash was found in the workbench history");
         }
 
         // Return the step ID (hash) instead of the message handler returned ID
diff --git a/packages/shared/projectUtils.ts b/packages/shared/projectUtils.ts
index d0a06345..d3ffe8fe 100644
--- a/packages/shared/projectUtils.ts
+++ b/packages/shared/projectUtils.ts
@@ -76,6 +76,8 @@ export function sendWasmMessage(message: Message): MessageResult {
 
   if (!result.success) {
     throw new Error(`[sendWasmMessage] message failed: ${result.data}`)
+  } else {
+    workbenchIsStale.set(true)
   }
 
   return result
diff --git a/packages/shared/stepTypeGuards.ts b/packages/shared/stepTypeGuards.ts
index 4739e574..0b1f18a3 100644
--- a/packages/shared/stepTypeGuards.ts
+++ b/packages/shared/stepTypeGuards.ts
@@ -19,29 +19,29 @@ export function isSketchStep(step: Step): step is SketchStep {
 
 // --- Sketch primitive operations ---
 // Any primitive operation
-export type SketchPrimitiveStep = Step & {result: {Primitive: WrappedPrimitive}}
+export type SketchPrimitiveStep = Step & {result: StepResult & {Primitive: WrappedPrimitive}}
 export function isSketchPrimitiveStep(step: Step): step is SketchPrimitiveStep {
   return typeof step.result === "object" && "Primitive" in step.result
 }
 
-export type SketchPointStep = SketchPrimitiveStep & {result: {Point2: Point2}, data: {SketchAddPoint: SketchAddPoint}}
+export type SketchPointStep = SketchPrimitiveStep & {result: {Primitive: {Point2: Point2}}, data: {SketchAddPoint: SketchAddPoint}}
 export function isSketchPointStep(step: Step): step is SketchPointStep {
-  return isSketchPrimitiveStep(step) && "SketchAddPoint" in step.data && "Point2" in step.result
+  return isSketchPrimitiveStep(step) && "SketchAddPoint" in step.data && "Point2" in step.result.Primitive
 }
 
-export type SketchLineStep = SketchPrimitiveStep & {result: {Line2: Line2}, data: {SketchAddLine: SketchAddLine}}
+export type SketchLineStep = SketchPrimitiveStep & {result: {Primitive: {Line2: Line2}}, data: {SketchAddLine: SketchAddLine}}
 export function isSketchLineStep(step: Step): step is SketchLineStep {
-  return isSketchPrimitiveStep(step) && "SketchAddLine" in step.data && "Line2" in step.result
+  return isSketchPrimitiveStep(step) && "SketchAddLine" in step.data && "Line2" in step.result.Primitive
 }
 
-export type SketchCircleStep = SketchPrimitiveStep & {result: {Circle2: Circle2}, data: {SketchAddCircle: SketchAddCircle}}
+export type SketchCircleStep = SketchPrimitiveStep & {result: {Primitive: {Circle2: Circle2}}, data: {SketchAddCircle: SketchAddCircle}}
 export function isSketchCircleStep(step: Step): step is SketchCircleStep {
-  return isSketchPrimitiveStep(step) && "SketchAddCircle" in step.data && "Circle2" in step.result
+  return isSketchPrimitiveStep(step) && "SketchAddCircle" in step.data && "Circle2" in step.result.Primitive
 }
 
-export type SketchArcStep = SketchPrimitiveStep & {result: {Arc2: Arc2}, data: {SketchAddArc: SketchAddArc}}
+export type SketchArcStep = SketchPrimitiveStep & {result: {Primitive: {Arc2: Arc2}}, data: {SketchAddArc: SketchAddArc}}
 export function isSketchArcStep(step: Step): step is SketchArcStep {
-  return isSketchPrimitiveStep(step) && "SketchAddArc" in step.data && "Arc2" in step.result
+  return isSketchPrimitiveStep(step) && "SketchAddArc" in step.data && "Arc2" in step.result.Primitive
 }
 
 // --- Sketch compound operations ---
@@ -53,7 +53,7 @@ export function isSketchCompoundStep(step: Step): step is SketchCompoundStep {
 // TODO: export rectangle
 // export type SketchRectangleStep = SketchCompoundStep & {result: Rectangle, data: SketchAddRectangle}
 // export function isSketchRectangleStep(step: Step): step is SketchRectangleStep {
-//   return isSketchCompoundStep(step) && "SketchAddRectangle" in step.data && "Rectangle" in step.result
+//   return isSketchCompoundStep(step) && "SketchAddRectangle" in step.data && "Rectangle" in step.result.Compound
 // }
 
 // --- Solid operations ---
diff --git a/packages/shared/stores.ts b/packages/shared/stores.ts
index 55e7b35c..ab78da6e 100644
--- a/packages/shared/stores.ts
+++ b/packages/shared/stores.ts
@@ -1,6 +1,6 @@
 import {Solid, StepHash, Project as WasmProject, Workbench} from "cadmium"
 import {writable} from "svelte/store"
-import type {MessageHistory, Project, Entity, EntityType, SnapEntity, PointLikeById, PreviewGeometry} from "./types"
+import type {MessageHistory, Project, Entity, EntityType, SnapEntity, PointLikeById, PreviewGeometry, Point2WithID} from "./types"
 import {isArcEntity, isCircleEntity, isEntity, isFaceEntity, isLineEntity, isMeshFaceEntity, isPlaneEntity, isPoint3DEntity, isPointEntity} from "./typeGuards"
 
 // prettier-ignore
@@ -18,7 +18,7 @@ export const workbenchIsStale = writable(false)
 export const featureIndex = writable<number>(1000)
 export const extrusionFeatures = writable<Entity[]>([])
 
-export const hiddenSketches = writable<number[]>([])
+export const hiddenSketches = writable<StepHash[]>([])
 export const sketchBeingEdited = writable<StepHash | null>(null)
 export const sketchTool = writable("")
 
@@ -29,7 +29,7 @@ export const selectionMin = writable(0)
 
 export const currentlyMousedOver = writable<SnapEntity[]>([])
 export const currentlySelected = writable<Entity[]>([])
-export const snapPoints = writable<PointLikeById[]>([])
+export const snapPoints = writable<Point2WithID[]>([])
 export const previewGeometry = writable<PreviewGeometry[]>([])
 
 export const messageHistory = writable<MessageHistory[]>([])
diff --git a/packages/shared/types.d.ts b/packages/shared/types.d.ts
index 7bf59124..099ce36f 100644
--- a/packages/shared/types.d.ts
+++ b/packages/shared/types.d.ts
@@ -1,11 +1,13 @@
-import { MessageResult, StepHash, Workbench } from "cadmium"
+import { MessageResult, Point2, StepHash, Workbench } from "cadmium"
 import { Message } from "./cadmium-api"
 import type { Vector2, Vector3, Vector2Like, Vector3Like } from "three"
 
-interface IDictionary<TValue> {
+export interface IDictionary<TValue> {
   [id: string]: TValue
 }
 
+export type Point2WithID = Point2 & { id?: StepHash }
+
 type WithTarget<Event, Target> = Event & { currentTarget: Target }
 
 type SetCameraFocus = (goTo: Vector3Like, lookAt: Vector3Like, up: Vector3Like) => void
@@ -335,9 +337,9 @@ interface ExtrusionSketchData {
 
 interface PreviewGeometry {
   type: EntityType
-  start?: PointLikeById
-  end?: PointLikeById
-  center?: PointLikeById
+  start?: Point2
+  end?: Point2
+  center?: Point2
   radius?: number
   x?: number
   y?: number