internal/service/gardens.go

@@ -166,7 +166,9 @@ func (s *Service) DeleteGarden(ctx context.Context, actorID, gardenID int64) err
 
 // gardenFromInput validates and normalizes input into a domain.Garden (without
 // identity/ownership fields). With applyDefaults, absent dimensions/unit are
-// filled in (create); without it, every field must be supplied (update).
+// filled in (create); without it, dimensions and unit must be supplied (update).
+// The grid size is the exception: 0 always means "unset" and is defaulted on both
+// paths, so an older client that omits it can't wipe the column to an invalid 0.
 func gardenFromInput(in GardenInput, applyDefaults bool) (*domain.Garden, error) {
 	name := strings.TrimSpace(in.Name)
 	if name == "" || len(name) > maxGardenNameLen {

web/src/editor/GardenCanvas.tsx

@@ -157,15 +157,14 @@ export function GardenCanvas({
     if (!rect) return
     const world = screenToWorld({ x: e.clientX - rect.left, y: e.clientY - rect.top }, viewport)
     const local = worldToLocal(world, { x: focusedObject.xCm, y: focusedObject.yCm }, focusedObject.rotationDeg)
-    const halfW = focusedObject.widthCm / 2
-    const halfH = focusedObject.heightCm / 2
-    // Snap the plant to the bed's grid when the bed opts in; snapLocalToBedGrid
-    // also clamps, so the plain clamp covers the non-snapping case.
-    const placed = focusedObject.snapToGrid
-      ? snapLocalToBedGrid(local, focusedObject.gridSizeCm, halfW, halfH)
-      : { x: Math.max(-halfW, Math.min(halfW, local.x)), y: Math.max(-halfH, Math.min(halfH, local.y)) }
-    const x = placed.x
-    const y = placed.y
+    // snapLocalToBedGrid clamps to the bed either way; step 0 (snapping off) makes
+    // it a pure clamp, so both paths go through one helper.
+    const { x, y } = snapLocalToBedGrid(
+      local,
+      focusedObject.snapToGrid ? focusedObject.gridSizeCm : 0,
+      focusedObject.widthCm / 2,
+      focusedObject.heightCm / 2,
+    )
     const radiusCm = Math.max(1.5 * armedPlant.spacingCm, 15)
     // Stay armed for repeat-placement; don't select (the placement sheet covers
     // the object, so a selection would be hidden until placement ends anyway).
@@ -178,9 +177,16 @@ export function GardenCanvas({
   // Draw the bed's own grid inside a focused plantable bed that has snapping on,
   // so the user sees exactly where plants will land. Lines are in the bed's local
   // frame (origin at center), anchored to the corner to match snapLocalToBedGrid.
-  const showBedGrid = !!focusedObject && focusedObject.plantable && focusedObject.snapToGrid
-  const bedVLines = showBedGrid ? bedGridLines(halfFW, focusedObject.gridSizeCm) : []
-  const bedHLines = showBedGrid ? bedGridLines(halfFH, focusedObject.gridSizeCm) : []
+  // Memoized so a high-frequency plop drag (which re-renders the canvas on every
+  // pointermove) doesn't rebuild the line arrays each frame. null when the focused
+  // object isn't a snapping plantable bed.
+  const bedGrid = useMemo(() => {
+    if (!focusedObject || !focusedObject.plantable || !focusedObject.snapToGrid) return null
+    return {
+      v: bedGridLines(focusedObject.widthCm / 2, focusedObject.gridSizeCm),
+      h: bedGridLines(focusedObject.heightCm / 2, focusedObject.gridSizeCm),
+    }
+  }, [focusedObject])
 
   return (
     <div ref={containerRef} className="relative h-full w-full overflow-hidden rounded-xl border border-border bg-bg">
@@ -210,12 +216,12 @@ export function GardenCanvas({
             </g>
           ))}
 
-          {showBedGrid && focusedObject && (
+          {focusedObject && bedGrid && (
             <g transform={objectTransform(focusedObject)} pointerEvents="none">
-              {bedVLines.map((x) => (
+              {bedGrid.v.map((x) => (
                 <line key={`v${x}`} x1={x} y1={-halfFH} x2={x} y2={halfFH} stroke="#3f8f4f" strokeOpacity={0.3} strokeWidth={1} vectorEffect="non-scaling-stroke" />
               ))}
-              {bedHLines.map((y) => (
+              {bedGrid.h.map((y) => (
                 <line key={`h${y}`} x1={-halfFW} y1={y} x2={halfFW} y2={y} stroke="#3f8f4f" strokeOpacity={0.3} strokeWidth={1} vectorEffect="non-scaling-stroke" />
               ))}
             </g>

web/src/editor/PlopOverlay.tsx

@@ -63,11 +63,6 @@ export function PlopOverlay({
     }
   }
 
-  const clampLocal = (p: Point): Point => ({
-    x: Math.max(-halfW, Math.min(halfW, p.x)),
-    y: Math.max(-halfH, Math.min(halfH, p.y)),
-  })
-
   const begin = (
     e: ReactPointerEvent,
     onMove: (e: PointerEvent) => EditorPlanting,
@@ -110,8 +105,9 @@ export function PlopOverlay({
       (ev) => {
         const p = ptr(ev)
         const moved: Point = { x: base.xCm + (p.x - start.x), y: base.yCm + (p.y - start.y) }
-        // snapLocalToBedGrid clamps too, so the plain clamp covers the non-snap case.
-        const next = snap ? snapLocalToBedGrid(moved, gridCm, halfW, halfH) : clampLocal(moved)
+        // snapLocalToBedGrid clamps either way; step 0 (snapping off) makes it a
+        // pure clamp, so both paths go through one helper.
+        const next = snapLocalToBedGrid(moved, snap ? gridCm : 0, halfW, halfH)
         return { ...base, xCm: next.x, yCm: next.y }
       },
       (f) => ({ id: base.id, version: base.version, xCm: f.xCm, yCm: f.yCm }),

web/src/lib/geometry.ts

@@ -91,12 +91,12 @@ export function snapPoint(p: Point, step: number): Point {
  * clamped, not snapped.
  */
 export function snapLocalToBedGrid(p: Point, step: number, halfW: number, halfH: number): Point {
-  const sx = step > 0 ? -halfW + Math.round((p.x + halfW) / step) * step : p.x
-  const sy = step > 0 ? -halfH + Math.round((p.y + halfH) / step) * step : p.y
-  return {
-    x: Math.max(-halfW, Math.min(halfW, sx)),
-    y: Math.max(-halfH, Math.min(halfH, sy)),
-  }
+  // Snap one axis to the grid anchored at -half (the bed's near edge), then clamp
+  // to [-half, half]. step<=0 skips the snap, so callers can pass step 0 to get a
+  // pure clamp — the non-snapping placement/move path — through the same helper.
+  const snapAxis = (v: number, half: number) =>
+    Math.max(-half, Math.min(half, step > 0 ? -half + Math.round((v + half) / step) * step : v))
+  return { x: snapAxis(p.x, halfW), y: snapAxis(p.y, halfH) }
 }
 
 /** Linear interpolation. */