Address Gadfly review on #8: modal focus/close, dim validation, dedup

Fixes from the PR #27 adversarial review (considered; not graded).

Correctness / error-handling
- Modal: focus once on mount and attach the keydown listener once (latest
  onClose/busy via refs), so a parent re-render (e.g. a background refetch)
  no longer re-fires focus() and steals it from the input being typed in.
- Modal takes a `busy` prop; while a save/delete is in flight, Escape and
  backdrop clicks don't dismiss it (form/delete modals pass busy=pending),
  so an action can't be interrupted mid-flight and lose its error.
- Form validates the *converted* centimeter values against the server's
  [1cm, 100m] bounds, so sub-cm / over-100m sizes fail client-side with a
  clear message instead of a generic server error.
- displayFromCm rounds imperial to 0.1 ft so an 8 ft garden (244 cm)
  prefills as "8", not "8.01".

Maintainability
- Extracted ui/field.ts (useFieldId + fieldControlClass) shared by
  TextField/TextArea/Select. Added a `danger` Button variant, used by the
  delete modal; card edit/delete buttons gained focus-visible rings.
- useUpdateGarden takes the id in its mutation variables (no dummy 0 during
  create). GardensPage shares a close handler; dropped a redundant zod
  annotation; 409 rebase reuses dimString; renamed `del` -> `deletion`.

Verified in a browser: 8 ft round-trips to a prefilled "8"; a sub-cm value
is rejected client-side with the modal staying open. tsc clean.

Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]>
Claude-Session: https://claude.ai/code/session_01JdQpdYYsTgtkJBxbcpAszi

web/src/lib/gardens.ts

@@ -6,7 +6,7 @@ import { z } from 'zod'
 import { ApiError, api } from './api'
 import type { UnitPref } from './units'
 
-const unitPrefSchema: z.ZodType<UnitPref> = z.enum(['metric', 'imperial'])
+const unitPrefSchema = z.enum(['metric', 'imperial'])
 
 export const gardenSchema = z.object({
   id: z.number(),
@@ -51,13 +51,16 @@ export function useCreateGarden() {
 }
 
 export interface GardenUpdate extends GardenInput {
+  id: number
   version: number
 }
 
-export function useUpdateGarden(id: number) {
+export function useUpdateGarden() {
   const qc = useQueryClient()
   return useMutation({
-    mutationFn: async (input: GardenUpdate): Promise<Garden> =>
+    // id travels with the mutation variables (not the hook) so callers don't need
+    // a placeholder id before a garden is chosen.
+    mutationFn: async ({ id, ...input }: GardenUpdate): Promise<Garden> =>
       gardenSchema.parse(await api.patch(`/gardens/${id}`, input)),
     onSuccess: () => qc.invalidateQueries({ queryKey: gardensKey }),
   })

web/src/lib/units.ts

@@ -8,6 +8,15 @@ const CM_PER_INCH = 2.54
 const CM_PER_METER = 100
 const INCHES_PER_FOOT = 12
 
+// Mirrors the server's garden dimension bounds (service/gardens.go): [1cm, 100m].
+export const MIN_DIMENSION_CM = 1
+export const MAX_DIMENSION_CM = 10_000
+
+/** Whether a centimeter dimension is within the server's accepted range. */
+export function isValidDimensionCm(cm: number): boolean {
+  return Number.isFinite(cm) && cm >= MIN_DIMENSION_CM && cm <= MAX_DIMENSION_CM
+}
+
 /** Feet (+ optional inches) → whole centimeters. */
 export function cmFromFtIn(feet: number, inches = 0): number {
   return Math.round((feet * INCHES_PER_FOOT + inches) * CM_PER_INCH)
@@ -23,11 +32,15 @@ export function cmFromDisplay(value: number, unit: UnitPref): number {
   return unit === 'imperial' ? cmFromFtIn(value) : cmFromMeters(value)
 }
 
-/** Centimeters → a number in the given unit, for prefilling an input field. */
+/** Centimeters → a number in the given unit, for prefilling an input field.
+ *  Rounded so cm-quantization doesn't show through (e.g. 244cm shows as 8 ft,
+ *  not 8.01): meters to the cm (2 dp), feet to 0.1 ft. */
 export function displayFromCm(cm: number, unit: UnitPref): number {
-  const value = unit === 'imperial' ? cm / CM_PER_INCH / INCHES_PER_FOOT : cm / CM_PER_METER
-  // Trim floating-point noise (e.g. 122cm → 4.0026ft → 4).
-  return Math.round(value * 100) / 100
+  if (unit === 'imperial') {
+    const feet = cm / CM_PER_INCH / INCHES_PER_FOOT
+    return Math.round(feet * 10) / 10
+  }
+  return Math.round((cm / CM_PER_METER) * 100) / 100
 }
 
 /** Centimeters → a human string in the given unit (e.g. "1.22 m" or "4′ 0″"). */