@defra/interactive-map 0.0.36-alpha → 0.0.38-alpha

package/plugins/draw/src/utils/undoStack.js

@@ -0,0 +1,31 @@
+/**
+ * Undo stack for draw operations.
+ * Calls onChange(length) whenever the stack changes so the UI can update.
+ *
+ * @param {(length: number) => void} onChange
+ */
+export const createUndoStack = (onChange) => {
+  const stack = []
+
+  return {
+    push (operation) {
+      stack.push(operation)
+      onChange(stack.length)
+    },
+
+    pop () {
+      const op = stack.pop()
+      onChange(stack.length)
+      return op
+    },
+
+    clear () {
+      stack.length = 0
+      onChange(stack.length)
+    },
+
+    get length () {
+      return stack.length
+    }
+  }
+}

package/plugins/draw/src/utils/undoStack.test.js

@@ -0,0 +1,49 @@
+import { createUndoStack } from './undoStack.js'
+
+describe('createUndoStack', () => {
+  test('push adds an operation and reports the new length', () => {
+    const onChange = jest.fn()
+    const stack = createUndoStack(onChange)
+
+    stack.push({ id: 1 })
+    stack.push({ id: 2 })
+
+    expect(stack.length).toBe(2)
+    expect(onChange).toHaveBeenNthCalledWith(1, 1)
+    expect(onChange).toHaveBeenNthCalledWith(2, 2)
+  })
+
+  test('pop returns and removes the last operation, reporting the length', () => {
+    const onChange = jest.fn()
+    const stack = createUndoStack(onChange)
+    stack.push({ id: 1 })
+    onChange.mockClear()
+
+    const op = stack.pop()
+
+    expect(op).toEqual({ id: 1 })
+    expect(stack.length).toBe(0)
+    expect(onChange).toHaveBeenCalledWith(0)
+  })
+
+  test('pop on an empty stack returns undefined and reports zero', () => {
+    const onChange = jest.fn()
+    const stack = createUndoStack(onChange)
+
+    expect(stack.pop()).toBeUndefined()
+    expect(onChange).toHaveBeenCalledWith(0)
+  })
+
+  test('clear empties the stack and reports zero', () => {
+    const onChange = jest.fn()
+    const stack = createUndoStack(onChange)
+    stack.push({ id: 1 })
+    stack.push({ id: 2 })
+    onChange.mockClear()
+
+    stack.clear()
+
+    expect(stack.length).toBe(0)
+    expect(onChange).toHaveBeenCalledWith(0)
+  })
+})

package/plugins/draw/src/validation/liveDrawChecks.js

@@ -0,0 +1,120 @@
+import { validateGeometry } from './validateGeometry.js'
+import { LIVE_RULES, HARD_RULES, MIN_VERTICES } from './rules.js'
+import { requestFrame, cancelFrame } from './liveStroke.js'
+
+/**
+ * Live validation driver for DRAW mode (draw_polygon/draw_line) only — edit mode
+ * has no Add-point gate and keeps using the plain createLiveStroke (liveStroke.js).
+ *
+ * On every rubber-band move, a user `onGeometryChange` callback is called ONCE,
+ * throttled to one call per animation frame (phase 'preview', with NO
+ * vertex-count floor — a location-based rule is meaningful even against the
+ * very first candidate point, before any vertex is committed). Its verdict is
+ * combined with two INDEPENDENTLY-floored built-in rule checks, each flip-guarded
+ * and reported through its own callback — `onChange(invalid, reason)` fires only
+ * when THAT gate's own state flips, same contract as createLiveStroke:
+ *   - LIVE_RULES (closed-ring self-intersect/area), floored at the geometry
+ *     type's minimum vertex count — self-intersection/area are meaningless
+ *     below that — reported via onStrokeChange (dashed stroke / Done gate).
+ *   - HARD_RULES (open-path self-intersect), never floored, so it still
+ *     protects placing an invalid first vertex — reported via onPlaceChange
+ *     (Add-point gate).
+ * Previously each gate ran its own independently-throttled call to the same
+ * user callback (one forcing phase 'preview', the other forcing phase 'place'),
+ * firing it twice per rubber-band move for what was really one live moment.
+ * This unifies that into a single call, whose verdict both gates share.
+ *
+ * Being flip-guarded itself (unlike an earlier version of this module), a
+ * caller only strictly needs createLiveStroke for onStrokeChange — where
+ * MaplibreDrawAdapter.js/OL DrawMode.js feed it into their existing shared
+ * `_liveStroke.set()` sink, since that instance is also driven independently
+ * by edit mode and must stay the single source of truth for the rendered
+ * stroke. onPlaceChange has no such cross-mode instance to stay in sync with —
+ * draw mode is its only caller — so it can emit CAN_PLACE_CHANGE directly.
+ *
+ * @param {object} params
+ * @param {(invalid: boolean, reason: string|null) => void} params.onStrokeChange
+ * @param {(vetoed: boolean, reason: string|null) => void} params.onPlaceChange
+ * @returns {{ update: Function, reset: Function, destroy: Function }}
+ */
+export const createLiveDrawChecks = ({ onStrokeChange, onPlaceChange }) => {
+  // A small flip-guarded gate — same shape as liveStroke.js's own `flip`, one
+  // per output so the stroke and placement verdicts track independently.
+  const makeGate = (onChange) => {
+    let invalid = false
+    return (next, reason) => {
+      if (next !== invalid) {
+        invalid = next
+        onChange(next, reason ?? null)
+      }
+    }
+  }
+  const flipStroke = makeGate(onStrokeChange)
+  const flipPlace = makeGate(onPlaceChange)
+
+  let customInvalid = false
+  let customReason = null
+  let frame = null
+  let pending = null
+
+  const cancelPending = () => {
+    if (frame != null) { cancelFrame(frame); frame = null }
+    pending = null
+  }
+
+  // One built-in rule set, its own floor, and the gate it drives — the stroke
+  // and placement checks are otherwise identical shape.
+  const evaluateGate = (feature, context, rules, floor, flip) => {
+    const numVertices = context.numVertices ?? 0
+    const result = numVertices < floor
+      ? { valid: true }
+      : validateGeometry(feature, { ...context, phase: 'preview' }, { rules })
+    flip(!result.valid || customInvalid, result.valid ? customReason : result.reason)
+  }
+
+  const recompute = () => {
+    if (!pending) { return }
+    const { feature, context } = pending
+    const min = MIN_VERTICES[feature?.geometry?.type] ?? 0
+    evaluateGate(feature, context, LIVE_RULES, min, flipStroke)
+    evaluateGate(feature, context, HARD_RULES, 0, flipPlace)
+  }
+
+  const runUserRule = () => {
+    frame = null
+    if (!pending) { return }
+    const { feature, context, onGeometryChange } = pending
+    const result = validateGeometry(feature, { ...context, phase: 'preview' }, { rules: [], onGeometryChange })
+    customInvalid = !result.valid
+    customReason = result.reason
+    recompute()
+  }
+
+  return {
+    // Re-evaluate the displayed geometry after a rubber-band move.
+    update ({ feature, context = {}, numVertices, onGeometryChange }) {
+      pending = { feature, context: { ...context, numVertices }, onGeometryChange }
+      // Built-in rules first, synchronously — immediate feedback either gate.
+      recompute()
+      // A user rule (if any) decides last, throttled to one frame; its cached
+      // verdict (customInvalid) feeds the next recompute() once it lands.
+      if (typeof onGeometryChange === 'function' && frame == null) {
+        frame = requestFrame(runUserRule)
+      }
+    },
+    // Authoritative reset for starting a fresh draw session: clears cached
+    // custom validity and drops any pending frame so a previous session's
+    // verdict can't leak, and re-asserts both gates back to valid — through
+    // the same flip guards, so it only fires what actually changed.
+    reset () {
+      cancelPending()
+      customInvalid = false
+      customReason = null
+      flipStroke(false, null)
+      flipPlace(false, null)
+    },
+    destroy () {
+      cancelPending()
+    }
+  }
+}

package/plugins/draw/src/validation/liveDrawChecks.test.js

@@ -0,0 +1,159 @@
+import { createLiveDrawChecks } from './liveDrawChecks.js'
+
+const poly = (ring) => ({ type: 'Feature', geometry: { type: 'Polygon', coordinates: [ring] } })
+
+// Closed-ring self-intersect only (LIVE_RULES fails, HARD_RULES/open-path passes) —
+// only the implicit closing edge crosses.
+const closingEdgeCrosses = poly([[0, 0], [2, 0], [0, 2], [2, 2]])
+// Open-path self-intersect (HARD_RULES fails) — also fails LIVE_RULES, since a
+// crossing open path implies a crossing closed one too.
+const openPathCrosses = poly([[0, 0], [2, 2], [2, 0], [0, 2]])
+const square = poly([[0, 0], [10, 0], [10, 10], [0, 10]])
+
+const setup = () => {
+  const onStrokeChange = jest.fn()
+  const onPlaceChange = jest.fn()
+  const checks = createLiveDrawChecks({ onStrokeChange, onPlaceChange })
+  return { onStrokeChange, onPlaceChange, checks }
+}
+
+beforeEach(() => jest.useFakeTimers())
+afterEach(() => jest.useRealTimers())
+
+describe('built-in rules (synchronous, independently floored, flip-guarded)', () => {
+  test('LIVE_RULES (closed ring) gates the stroke; HARD_RULES (open path) gates placement — independently', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    checks.update({ feature: closingEdgeCrosses, numVertices: 3 })
+    expect(onStrokeChange).toHaveBeenCalledWith(true, expect.any(String)) // dashed
+    expect(onPlaceChange).not.toHaveBeenCalled() // still placeable — never flipped from its valid default
+  })
+
+  test('an open-path crossing vetoes placement too, since it also crosses closed', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    checks.update({ feature: openPathCrosses, numVertices: 3 })
+    expect(onStrokeChange).toHaveBeenCalledWith(true, expect.any(String))
+    expect(onPlaceChange).toHaveBeenCalledWith(true, expect.any(String))
+  })
+
+  test('a valid shape leaves both gates open, and flips them back once they were invalid', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    checks.update({ feature: openPathCrosses, numVertices: 3 }) // both invalid first
+    checks.update({ feature: square, numVertices: 3 }) // valid again — should flip back
+    expect(onStrokeChange).toHaveBeenLastCalledWith(false, null)
+    expect(onPlaceChange).toHaveBeenLastCalledWith(false, null)
+  })
+
+  test('LIVE_RULES stays floored below the minimum vertex count — never flips at all', () => {
+    const { onStrokeChange, checks } = setup()
+    checks.update({ feature: closingEdgeCrosses, numVertices: 1 })
+    expect(onStrokeChange).not.toHaveBeenCalled()
+  })
+
+  test('numVertices defaults to 0 when omitted from context', () => {
+    const { onStrokeChange, checks } = setup()
+    checks.update({ feature: closingEdgeCrosses })
+    expect(onStrokeChange).not.toHaveBeenCalled() // treated as 0 — below the floor
+  })
+
+  test('HARD_RULES is never floored — it must protect placing an invalid first vertex', () => {
+    const { onPlaceChange, checks } = setup()
+    // A single point can never self-intersect, so this stays placeable — the
+    // point is that placement is EVALUATED (not skipped) even at numVertices 0,
+    // proven by the user-callback tests below where a custom veto DOES apply here.
+    checks.update({ feature: poly([[0, 0]]), numVertices: 0 })
+    expect(onPlaceChange).not.toHaveBeenCalled() // stayed valid — no flip to report
+  })
+})
+
+describe('user callback (throttled, single call drives both gates)', () => {
+  test('runs ONCE per frame with phase preview, not once per gate', () => {
+    const { checks } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    checks.update({ feature: square, numVertices: 3, onGeometryChange })
+    expect(onGeometryChange).not.toHaveBeenCalled() // deferred to the frame
+    jest.runAllTimers()
+    expect(onGeometryChange).toHaveBeenCalledTimes(1)
+    expect(onGeometryChange).toHaveBeenCalledWith(expect.objectContaining({ feature: square, numVertices: 3, phase: 'preview' }))
+  })
+
+  test('a veto flips BOTH the stroke and placement gates from the one call', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    const onGeometryChange = () => ({ valid: false, reason: 'outside region' })
+    checks.update({ feature: square, numVertices: 3, onGeometryChange })
+    jest.runAllTimers()
+    expect(onStrokeChange).toHaveBeenLastCalledWith(true, 'outside region')
+    expect(onPlaceChange).toHaveBeenLastCalledWith(true, 'outside region')
+  })
+
+  test('runs even with zero committed vertices — a location-based rule is meaningful against the first candidate point', () => {
+    const { onPlaceChange, checks } = setup()
+    const onGeometryChange = jest.fn(() => ({ valid: false, reason: 'outside region' }))
+    checks.update({ feature: poly([[0, 0]]), numVertices: 0, onGeometryChange })
+    jest.runAllTimers()
+    expect(onGeometryChange).toHaveBeenCalledWith(expect.objectContaining({ numVertices: 0, phase: 'preview' }))
+    expect(onPlaceChange).toHaveBeenLastCalledWith(true, 'outside region')
+  })
+
+  test('a built-in HARD_RULES failure still applies even when the user callback passes', () => {
+    const { onPlaceChange, checks } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    checks.update({ feature: openPathCrosses, numVertices: 3, onGeometryChange })
+    jest.runAllTimers()
+    expect(onPlaceChange).toHaveBeenLastCalledWith(true, expect.any(String))
+  })
+
+  test('runs once per frame using the latest geometry (trailing edge)', () => {
+    const { checks } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    checks.update({ feature: square, numVertices: 3, onGeometryChange })
+    checks.update({ feature: square, numVertices: 4, onGeometryChange })
+    const latest = poly([[0, 0], [20, 0], [20, 20], [0, 20]])
+    checks.update({ feature: latest, numVertices: 5, onGeometryChange })
+    jest.runAllTimers()
+    expect(onGeometryChange).toHaveBeenCalledTimes(1)
+    expect(onGeometryChange).toHaveBeenCalledWith(expect.objectContaining({ feature: latest, numVertices: 5 }))
+  })
+})
+
+describe('flip guard', () => {
+  test('each gate fires only when its own state flips, not on every update', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    checks.update({ feature: openPathCrosses, numVertices: 3 })
+    checks.update({ feature: openPathCrosses, numVertices: 3 })
+    checks.update({ feature: openPathCrosses, numVertices: 3 })
+    expect(onStrokeChange).toHaveBeenCalledTimes(1)
+    expect(onPlaceChange).toHaveBeenCalledTimes(1)
+  })
+
+  test('reset() is a no-op for a gate that was never invalid', () => {
+    const { onStrokeChange, onPlaceChange, checks } = setup()
+    checks.update({ feature: square, numVertices: 3 }) // valid — neither gate ever flips
+    checks.reset()
+    expect(onStrokeChange).not.toHaveBeenCalled()
+    expect(onPlaceChange).not.toHaveBeenCalled()
+  })
+})
+
+describe('reset / destroy', () => {
+  test('reset() clears the cached custom verdict and drops a pending frame', () => {
+    const { onStrokeChange, checks } = setup()
+    const onGeometryChange = jest.fn(() => ({ valid: false, reason: 'outside region' }))
+    checks.update({ feature: square, numVertices: 3, onGeometryChange })
+    jest.runAllTimers()
+    expect(onStrokeChange).toHaveBeenLastCalledWith(true, 'outside region')
+
+    checks.reset()
+    onGeometryChange.mockClear()
+    checks.update({ feature: square, numVertices: 3 }) // fresh session, no callback this time
+    expect(onStrokeChange).toHaveBeenLastCalledWith(false, null)
+  })
+
+  test('destroy() cancels a pending user-rule frame', () => {
+    const { checks } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    checks.update({ feature: square, numVertices: 3, onGeometryChange })
+    checks.destroy()
+    jest.runAllTimers()
+    expect(onGeometryChange).not.toHaveBeenCalled()
+  })
+})

package/plugins/draw/src/validation/liveStroke.js

@@ -0,0 +1,85 @@
+import { validateDisplayedGeometry } from './validateGeometry.js'
+
+// Shared with liveDrawChecks.js — the same one-call-per-frame throttle for a
+// user rule of unknown cost, used both for the invalid stroke and (there) the
+// combined draw-mode live checks.
+export const requestFrame = (cb) =>
+  (typeof requestAnimationFrame === 'function' ? requestAnimationFrame(cb) : setTimeout(cb, 16))
+export const cancelFrame = (id) =>
+  (typeof cancelAnimationFrame === 'function' ? cancelAnimationFrame(id) : clearTimeout(id))
+
+/**
+ * Engine-agnostic driver for a live validity signal while drawing/editing —
+ * the invalid stroke by default, or (via `validate`) any other continuously
+ * re-evaluated verdict such as the Add-point placement gate.
+ *
+ * On every rubber-band/drag move the caller passes the displayed geometry (placed
+ * vertices + cursor). The default rules run synchronously for immediate feedback;
+ * a user `onGeometryChange` callback — whose cost is unknown — is throttled to one
+ * call per animation frame using the latest geometry (trailing edge), so an
+ * arbitrary user rule can't jank the drag. The default-fail path short-circuits
+ * (no user call) and cancels any pending frame so a stale evaluation can't flip
+ * the state back. `onChange(invalid, reason)` fires only when the state flips.
+ *
+ * @param {object} params
+ * @param {(invalid: boolean, reason: string|null) => void} params.onChange
+ * @param {Function} [params.validate] - (feature, context, config) => { valid, reason };
+ *   defaults to validateDisplayedGeometry (the invalid-stroke rules)
+ * @returns {{ update: Function, set: Function, reset: Function, destroy: Function }}
+ */
+export const createLiveStroke = ({ onChange, validate = validateDisplayedGeometry }) => {
+  let invalid = false
+  let frame = null
+  let pending = null
+
+  const cancelPending = () => {
+    if (frame != null) { cancelFrame(frame); frame = null }
+    pending = null
+  }
+
+  const flip = (next, reason) => {
+    if (next !== invalid) {
+      invalid = next
+      onChange(next, reason ?? null)
+    }
+  }
+
+  const runUserRule = () => {
+    frame = null
+    if (!pending) { return }
+    const { feature, context, onGeometryChange } = pending
+    const { valid, reason } = validate(feature, context, { onGeometryChange })
+    flip(!valid, reason)
+  }
+
+  return {
+    // Re-evaluate the displayed geometry after a rubber-band move.
+    update ({ feature, context = {}, numVertices, onGeometryChange }) {
+      const ctx = { ...context, numVertices }
+      // Default rules first, synchronously — immediate feedback on self-intersection / area.
+      const base = validate(feature, ctx)
+      if (!base.valid) { cancelPending(); flip(true, base.reason); return }
+      // Default rules pass — a user rule (if any) decides, throttled to one frame.
+      if (typeof onGeometryChange !== 'function') { cancelPending(); flip(false, null); return }
+      pending = { feature, context: ctx, onGeometryChange }
+      if (frame == null) { frame = requestFrame(runUserRule) }
+    },
+    // Authoritative external write — a committed verdict (events.js) or a mode
+    // reset. Applies through the same flip guard so the cached state always
+    // mirrors what is rendered, and drops any pending user-rule frame so a stale
+    // live evaluation can't overwrite it a frame later.
+    set (next, reason) {
+      cancelPending()
+      flip(next, reason ?? null)
+    },
+    // Re-assert the cached state through onChange unconditionally — for callers
+    // whose rendered output was reset behind the controller's back (e.g. a map
+    // style reload re-adding layers with their spec-default visibility).
+    refresh () {
+      onChange(invalid, null)
+    },
+    destroy () {
+      cancelPending()
+    }
+  }
+}

package/plugins/draw/src/validation/liveStroke.test.js

@@ -0,0 +1,150 @@
+import { createLiveStroke } from './liveStroke.js'
+
+const poly = (ring) => ({ type: 'Feature', geometry: { type: 'Polygon', coordinates: [ring] } })
+
+const square = poly([[0, 0], [10, 0], [10, 10], [0, 10]])
+const bowtie = poly([[0, 0], [10, 10], [10, 0], [0, 10]])
+
+const setup = () => {
+  const onChange = jest.fn()
+  const stroke = createLiveStroke({ onChange })
+  return { onChange, stroke }
+}
+
+beforeEach(() => jest.useFakeTimers())
+afterEach(() => jest.useRealTimers())
+
+describe('default rules (synchronous)', () => {
+  test('a failing default rule flips dashed immediately with the reason', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    expect(onChange).toHaveBeenCalledWith(true, expect.stringMatching(/intersect/i))
+  })
+
+  test('going valid again flips back solid', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    stroke.update({ feature: square, numVertices: 3 })
+    expect(onChange).toHaveBeenLastCalledWith(false, null)
+  })
+
+  test('onChange fires only when the state flips, not on every update', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    expect(onChange).toHaveBeenCalledTimes(1)
+  })
+
+  test('below the minimum vertex count the shape is part-drawn — never dashed', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 2 })
+    expect(onChange).not.toHaveBeenCalled()
+  })
+
+  test('a default-rule failure never invokes the user callback', () => {
+    const { stroke } = setup()
+    const onGeometryChange = jest.fn()
+    stroke.update({ feature: bowtie, numVertices: 3, onGeometryChange })
+    jest.runAllTimers()
+    expect(onGeometryChange).not.toHaveBeenCalled()
+  })
+})
+
+describe('user callback (throttled)', () => {
+  test('runs once per frame with the latest geometry (trailing edge)', () => {
+    const { stroke } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange })
+    stroke.update({ feature: square, numVertices: 4, onGeometryChange })
+    const latest = poly([[0, 0], [20, 0], [20, 20], [0, 20]])
+    stroke.update({ feature: latest, numVertices: 5, onGeometryChange })
+    expect(onGeometryChange).not.toHaveBeenCalled() // nothing synchronous
+    jest.runAllTimers()
+    expect(onGeometryChange).toHaveBeenCalledTimes(1)
+    expect(onGeometryChange).toHaveBeenCalledWith(expect.objectContaining({ feature: latest, numVertices: 5 }))
+  })
+
+  test('a user-callback veto flips dashed with its reason', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange: () => ({ valid: false, reason: 'outside region' }) })
+    jest.runAllTimers()
+    expect(onChange).toHaveBeenCalledWith(true, 'outside region')
+  })
+
+  test('a synchronous default failure cancels a pending user-rule frame', () => {
+    const { onChange, stroke } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange })
+    stroke.update({ feature: bowtie, numVertices: 3, onGeometryChange }) // sync dashed
+    jest.runAllTimers()
+    expect(onGeometryChange).not.toHaveBeenCalled() // stale frame dropped
+    expect(onChange).toHaveBeenLastCalledWith(true, expect.any(String))
+  })
+
+  test('without a user callback a valid update settles solid immediately', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    stroke.update({ feature: square, numVertices: 3 })
+    expect(onChange).toHaveBeenLastCalledWith(false, null)
+    expect(jest.getTimerCount()).toBe(0)
+  })
+})
+
+describe('custom validate function', () => {
+  test('drives both the synchronous default pass and the throttled user pass', () => {
+    const onChange = jest.fn()
+    const validate = jest.fn((feature, context, config) =>
+      config?.onGeometryChange ? config.onGeometryChange(feature, context) : { valid: true })
+    const stroke = createLiveStroke({ onChange, validate })
+    const onGeometryChange = jest.fn(() => ({ valid: false, reason: 'vetoed' }))
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange })
+    expect(validate).toHaveBeenCalledWith(square, expect.objectContaining({ numVertices: 3 }))
+    jest.runAllTimers()
+    expect(onChange).toHaveBeenCalledWith(true, 'vetoed')
+  })
+})
+
+describe('set / reset / destroy', () => {
+  test('set() applies through the flip guard and drops any pending frame', () => {
+    const { onChange, stroke } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange })
+    stroke.set(true, 'committed invalid')
+    expect(onChange).toHaveBeenCalledWith(true, 'committed invalid')
+    jest.runAllTimers()
+    expect(onGeometryChange).not.toHaveBeenCalled() // stale live frame dropped
+    onChange.mockClear()
+    stroke.set(true) // same state — guarded no-op
+    expect(onChange).not.toHaveBeenCalled()
+  })
+
+  test('set() keeps the cache in sync so the next live update flips correctly', () => {
+    const { onChange, stroke } = setup()
+    stroke.set(true)
+    onChange.mockClear()
+    stroke.update({ feature: square, numVertices: 3 }) // valid → back solid
+    expect(onChange).toHaveBeenCalledWith(false, null)
+  })
+
+  test('refresh() re-asserts the cached state unconditionally (style-reload resync)', () => {
+    const { onChange, stroke } = setup()
+    stroke.update({ feature: bowtie, numVertices: 3 })
+    onChange.mockClear()
+    stroke.refresh() // rendered output was reset externally — re-apply dashed
+    expect(onChange).toHaveBeenCalledWith(true, null)
+    stroke.update({ feature: square, numVertices: 3 })
+    onChange.mockClear()
+    stroke.refresh()
+    expect(onChange).toHaveBeenCalledWith(false, null)
+  })
+
+  test('destroy() cancels a pending user-rule frame', () => {
+    const { stroke } = setup()
+    const onGeometryChange = jest.fn(() => true)
+    stroke.update({ feature: square, numVertices: 3, onGeometryChange })
+    stroke.destroy()
+    jest.runAllTimers()
+    expect(onGeometryChange).not.toHaveBeenCalled()
+  })
+})

package/plugins/draw/src/validation/rules.areaError.test.js

@@ -0,0 +1,12 @@
+import { nonZeroArea } from './rules.js'
+
+// A separate file is required: this file-level @turf/area mock is hoisted above the
+// import and applies to the whole file, so it can't live in rules.test.js without
+// breaking the tests there that rely on the real area calculation. It covers the
+// defensive catch in nonZeroArea (a turf failure is treated as "skip / valid").
+jest.mock('@turf/area', () => ({ __esModule: true, default: jest.fn(() => { throw new Error('turf boom') }) }))
+
+test('nonZeroArea treats a turf area failure as a skip (valid)', () => {
+  const feature = { type: 'Feature', geometry: { type: 'Polygon', coordinates: [[[0, 0], [1, 0], [1, 1]]] } }
+  expect(nonZeroArea(feature)).toEqual({ valid: true })
+})