@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/paint-pass-through.test.ts

@@ -0,0 +1,122 @@
+import { describe, expect, it } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import { setSurfaceRaycastLayers } from '@pascal-app/viewer'
+import {
+  BoxGeometry,
+  ExtrudeGeometry,
+  Group,
+  type Intersection,
+  Mesh,
+  MeshBasicMaterial,
+  Path,
+  Ray,
+  Shape,
+  Vector3,
+} from 'three'
+import { openingPartHidden, paintPassesThrough, wallHitInOpening } from './paint-pass-through'
+
+describe('paint passes through an empty opening', () => {
+  const door = { id: 'door_g', type: 'door' } as unknown as AnyNode
+  const win = { id: 'window_g', type: 'window' } as unknown as AnyNode
+  const wall = { id: 'wall_g', type: 'wall' } as unknown as AnyNode
+
+  it('a door or window with no part under the cursor lets the pointer through', () => {
+    expect(paintPassesThrough(door, null)).toBe(true)
+    expect(paintPassesThrough(win, null)).toBe(true)
+  })
+
+  it('its parts still paint, and other kinds keep the hover', () => {
+    expect(paintPassesThrough(door, 'frame')).toBe(false)
+    expect(paintPassesThrough(win, 'glass')).toBe(false)
+    expect(paintPassesThrough(wall, null)).toBe(false)
+  })
+
+  // A 4 m × 3 m wall, 0.2 m thick, with a 2 m × 2.4 m opening down to the floor.
+  const outline = new Shape()
+  outline.moveTo(0, 0)
+  outline.lineTo(4, 0)
+  outline.lineTo(4, 3)
+  outline.lineTo(0, 3)
+  outline.lineTo(0, 0)
+  const opening = new Path()
+  opening.moveTo(1, 0.001)
+  opening.lineTo(1, 2.4)
+  opening.lineTo(3, 2.4)
+  opening.lineTo(3, 0.001)
+  opening.lineTo(1, 0.001)
+  outline.holes.push(opening)
+  const drawn = new Mesh(new ExtrudeGeometry(outline, { depth: 0.2, bevelEnabled: false }))
+  drawn.updateMatrixWorld(true)
+  // The uncut collision mesh's front face sits at z = 0.2.
+  const at = (x: number, y: number) => {
+    const ray = new Ray(new Vector3(x, y, 5), new Vector3(0, 0, -1))
+    return wallHitInOpening(drawn, ray, 5 - 0.2)
+  }
+
+  it("a wall's collision hit in its opening passes through", () => {
+    expect(at(2, 1)).toBe(true)
+    expect(at(2, 0.05)).toBe(true)
+  })
+
+  it('a hit on the wall itself, beside or above the opening, stays on the wall', () => {
+    expect(at(0.5, 1)).toBe(false)
+    expect(at(2, 2.7)).toBe(false)
+  })
+
+  it('a grazing ray that meets the reveal inside the opening is the wall', () => {
+    // Enters the opening 2 cm from its left jamb, heading left: it meets the jamb.
+    const ray = new Ray(new Vector3(1.02 + 0.3 * 4.8, 1, 5), new Vector3(-0.3, 0, -1).normalize())
+    expect(wallHitInOpening(drawn, ray, 4.8 * Math.hypot(0.3, 1))).toBe(false)
+    // The same angle through the middle of the opening passes.
+    const middle = new Ray(new Vector3(2 + 0.3 * 4.8, 1, 5), new Vector3(-0.3, 0, -1).normalize())
+    expect(wallHitInOpening(drawn, middle, 4.8 * Math.hypot(0.3, 1))).toBe(true)
+  })
+
+  it('without a drawn mesh the hit is the wall', () => {
+    expect(wallHitInOpening(null, new Ray(), 1)).toBe(false)
+  })
+
+  it('a drawn mesh with a group its material array has no entry for is the wall, without throwing', () => {
+    const torn = new Mesh(drawn.geometry.clone(), [new MeshBasicMaterial()])
+    torn.geometry.clearGroups()
+    torn.geometry.addGroup(0, Number.POSITIVE_INFINITY, 3)
+    torn.updateMatrixWorld(true)
+    const ray = new Ray(new Vector3(2, 1, 5), new Vector3(0, 0, -1))
+    expect(() => wallHitInOpening(torn, ray, 5 - 0.2)).not.toThrow()
+    expect(wallHitInOpening(torn, ray, 5 - 0.2)).toBe(false)
+  })
+})
+
+describe('a door part found behind the floor seen through its opening', () => {
+  // A door root with its invisible opening proxy and one tagged jamb at x = 1,
+  // standing in a wall along z = 0; the floor in front of it at y = 0.
+  const door = new Group()
+  const cutout = new Mesh(new BoxGeometry(2, 2.4, 0.3))
+  cutout.name = 'cutout'
+  cutout.position.set(0, 1.2, 0)
+  const jamb = new Mesh(new BoxGeometry(0.1, 2.4, 0.2))
+  jamb.userData.slotId = 'frame'
+  jamb.position.set(0.95, 1.2, 0)
+  door.add(cutout, jamb)
+  for (const mesh of [cutout, jamb]) setSurfaceRaycastLayers(mesh.layers)
+  door.updateMatrixWorld(true)
+  const floor = { distance: 3, object: new Mesh() } as unknown as Intersection
+  const collision = { distance: 2.5, object: Object.assign(new Mesh(), { name: 'collision-mesh' }) }
+
+  it('the floor in front of the part is what the pointer is on', () => {
+    // Down through the opening toward the jamb's foot, ~3.8 m away; the floor is at 3 m.
+    const ray = new Ray(new Vector3(0.2, 3.5, 2), new Vector3(0.75, -3.2, -2).normalize())
+    expect(openingPartHidden(door, ray, [])).toBe(false)
+    expect(openingPartHidden(door, ray, [floor])).toBe(true)
+  })
+
+  it('a part nearer than anything else stays the door (the host wall does not count)', () => {
+    const ray = new Ray(new Vector3(0.95, 1, 5), new Vector3(0, 0, -1))
+    expect(openingPartHidden(door, ray, [collision as unknown as Intersection])).toBe(false)
+  })
+
+  it('an opening with no part along the ray passes through', () => {
+    const ray = new Ray(new Vector3(0, 1, 5), new Vector3(0, 0, -1))
+    expect(openingPartHidden(door, ray, [])).toBe(true)
+  })
+})

package/src/lib/paint-pass-through.ts

@@ -0,0 +1,78 @@
+import type { AnyNode } from '@pascal-app/core'
+import { hasMaterialsForGroups, setSurfaceRaycastLayers } from '@pascal-app/viewer'
+import { type Intersection, Mesh, type Object3D, type Ray, Raycaster } from 'three'
+
+/**
+ * Whether the paint pointer passes through `node`: a door or window with no
+ * part under the cursor (an open garage door, the empty opening its proxy
+ * spans) is not there for paint, so the surface behind it is what paints.
+ */
+export function paintPassesThrough(node: AnyNode, role: string | null): boolean {
+  return role === null && (node.type === 'door' || node.type === 'window')
+}
+
+const drawnRaycaster = new Raycaster()
+const partRaycaster = new Raycaster()
+setSurfaceRaycastLayers(partRaycaster.layers)
+
+const isWithin = (object: Object3D | null, root: Object3D) => {
+  for (let at = object; at; at = at.parent) if (at === root) return true
+  return false
+}
+
+/**
+ * Whether the paintable part a door or window resolves behind its proxy is
+ * hidden: its opening proxy wins the scene raycast, and the part is then
+ * found along the whole ray — even past the floor seen through the opening.
+ * A surface of anything else hit before that part (walls aside: their
+ * collision meshes span the opening, see `wallHitInOpening`) is what the
+ * pointer is on.
+ */
+export function openingPartHidden(
+  opening: Object3D | null | undefined,
+  ray: Ray,
+  intersections: readonly Intersection[],
+): boolean {
+  if (!opening) return false
+  partRaycaster.ray.copy(ray)
+  const part = partRaycaster
+    .intersectObject(opening, true)
+    .find((hit) => typeof (hit.object.userData as { slotId?: unknown }).slotId === 'string')
+  if (!part) return true
+  return intersections.some(
+    (hit) =>
+      hit.distance < part.distance - 1e-4 &&
+      hit.object.name !== WALL_COLLISION_MESH &&
+      !isWithin(hit.object, opening),
+  )
+}
+
+const WALL_COLLISION_MESH = 'collision-mesh'
+
+/**
+ * Whether a wall hit lands in one of the wall's holes. A wall is picked through
+ * an uncut collision mesh, so its hits cover its openings too — the open garage
+ * door, the step under a doorway. The wall as drawn (`drawn`, its registered
+ * mesh, with the cuts) decides: nothing of it along the ray past the hit means
+ * the pointer is looking through the wall, not at it. A hit on a reveal inside
+ * the opening is still the wall.
+ */
+export function wallHitInOpening(
+  drawn: Object3D | null | undefined,
+  ray: Ray,
+  hitDistance: number,
+): boolean {
+  // A mesh caught between a palette and the groups a preview gave it cannot be
+  // raycast (three reads each group's material); the hit stands this move.
+  if (!(drawn instanceof Mesh && hasMaterialsForGroups(drawn))) return false
+  drawnRaycaster.ray.copy(ray)
+  drawnRaycaster.far = Number.POSITIVE_INFINITY
+  const hits: Intersection[] = []
+  // The drawn mesh opts out of scene raycasts (batched walls); ask it directly.
+  Mesh.prototype.raycast.call(drawn, drawnRaycaster, hits)
+  // A ray through the opening can still clip the reveal behind the hit; allow
+  // for the deepest wall a ray crosses at a grazing angle.
+  return !hits.some((hit) => hit.distance <= hitDistance + WALL_DEPTH_ALLOWANCE)
+}
+
+const WALL_DEPTH_ALLOWANCE = 2

package/src/lib/paint-region-hover.ts

@@ -0,0 +1,25 @@
+import { useFloorRegionDraft } from './floor-region-session'
+import { type PaintMode, paintRegionTargets, usePaintRegionMode } from './paint-region-mode'
+import { useWallPaintRegionSession } from './wall-paint-region-session'
+
+/** Whether a region sub-mode draws on what the pointer is over. */
+export function paintRegionHovering(
+  mode: PaintMode,
+  over: { wall: boolean; floor: boolean },
+): boolean {
+  const targets = paintRegionTargets(mode)
+  return (targets.wall && over.wall) || (targets.floor && over.floor)
+}
+
+/**
+ * Whether the pointer is over a surface the active region sub-mode draws on —
+ * a wall face (Rectangle) or a room floor — or a region is being drawn. The
+ * paint cursor and the HUD read it: region modes stand the whole-surface hover
+ * down, so its "nothing paintable here" never speaks for them.
+ */
+export function usePaintRegionHovering(): boolean {
+  const mode = usePaintRegionMode((state) => state.mode)
+  const wall = useWallPaintRegionSession((state) => state.preview !== null)
+  const floor = useFloorRegionDraft((state) => state.hover !== null || state.draft !== null)
+  return paintRegionHovering(mode, { wall, floor })
+}

package/src/lib/paint-region-mode.ts

@@ -0,0 +1,154 @@
+import { create } from 'zustand'
+import type { ActivePaintMaterial } from './material-paint'
+import { isTypingTarget } from './typing-target'
+
+/**
+ * What a paint click does: paint the whole surface under it, draw part of a
+ * surface first, or erase. The one source of truth for the paint sub-mode — the
+ * panel, the HUD, the cursor and the gestures all read `mode` here.
+ *   - `surface`   — a click paints the whole surface under it
+ *   - `rectangle` — a box on a wall face, pressed anywhere on it, or on a room floor
+ *   - `polygon`   — clicked points on a room floor
+ *   - `erase`     — a click removes a painted part, or resets a painted surface
+ *   - `pick`      — the eyedropper: a click takes the material shown under it
+ */
+export type PaintRegionMode = 'surface' | 'rectangle' | 'polygon'
+export type PaintMode = PaintRegionMode | 'erase' | 'pick'
+
+export const usePaintRegionMode = create<{
+  mode: PaintMode
+  /** The last painting (not erasing) sub-mode: where the paint tool and a colour pick return. */
+  drawMode: PaintRegionMode
+  /** The sub-mode the eyedropper came from, where it returns. */
+  pickReturn: PaintMode
+  /** What the eyedropper would take from the surface under the cursor. */
+  picked: ActivePaintMaterial | null
+  setMode: (mode: PaintMode) => void
+  /** Short text the HUD shows for a refused gesture (e.g. the per-face cap). */
+  notice: string | null
+  setNotice: (notice: string | null) => void
+}>((set) => ({
+  mode: 'surface',
+  drawMode: 'surface',
+  pickReturn: 'surface',
+  picked: null,
+  setMode: (mode) =>
+    set((state) => ({
+      mode,
+      notice: null,
+      picked: null,
+      ...(mode === 'pick'
+        ? state.mode === 'pick'
+          ? {}
+          : { pickReturn: state.mode }
+        : mode === 'erase'
+          ? {}
+          : { drawMode: mode }),
+    })),
+  notice: null,
+  setNotice: (notice) => set({ notice }),
+}))
+
+export function isPaintErasing(): boolean {
+  return usePaintRegionMode.getState().mode === 'erase'
+}
+
+export function isPaintPicking(): boolean {
+  return usePaintRegionMode.getState().mode === 'pick'
+}
+
+/**
+ * Where the eyedropper goes once it took a material: the sub-mode it came from,
+ * except erase — a picked material is for painting.
+ */
+export function paintPickReturnMode(): PaintRegionMode {
+  const { pickReturn, drawMode } = usePaintRegionMode.getState()
+  return pickReturn === 'erase' || pickReturn === 'pick' ? drawMode : pickReturn
+}
+
+/** Leaves the eyedropper without taking anything (the held key released). */
+export function endPaintPick(): void {
+  const { mode, pickReturn } = usePaintRegionMode.getState()
+  if (mode === 'pick')
+    usePaintRegionMode.getState().setMode(pickReturn === 'pick' ? 'surface' : pickReturn)
+}
+
+/** Erasing and the eyedropper end with the paint session: the next one starts on the last painting sub-mode. */
+export function endPaintSession(): void {
+  const { mode, drawMode, notice, picked } = usePaintRegionMode.getState()
+  if (mode !== drawMode || notice !== null || picked !== null)
+    usePaintRegionMode.setState({ mode: drawMode, notice: null, picked: null })
+}
+
+/** A new project starts on whole-surface paint. */
+export function resetPaintMode(): void {
+  usePaintRegionMode.setState({
+    mode: 'surface',
+    drawMode: 'surface',
+    pickReturn: 'surface',
+    picked: null,
+    notice: null,
+  })
+}
+
+/** Whether a region sub-mode owns the paint tool's pointer (not whole-surface paint or erase). */
+export function paintRegionModeActive(editorMode: string): boolean {
+  const { mode } = usePaintRegionMode.getState()
+  return editorMode === 'material-paint' && (mode === 'rectangle' || mode === 'polygon')
+}
+
+/** Which surfaces a sub-mode draws on. */
+export function paintRegionTargets(mode: PaintMode): { wall: boolean; floor: boolean } {
+  return { wall: mode === 'rectangle', floor: mode === 'rectangle' || mode === 'polygon' }
+}
+
+/** What the HUD asks for while the pointer is over nothing the sub-mode draws on. */
+export function paintRegionHoverHint(mode: 'rectangle' | 'polygon'): string {
+  return mode === 'polygon' ? 'Hover a floor or ceiling' : 'Hover a wall, floor or ceiling'
+}
+
+/**
+ * Holding Alt/Option while painting whole surfaces turns the eyedropper on;
+ * letting go (or the window losing focus) turns it off, and Escape leaves it
+ * from its icon too. Erasing picks nothing, and the region sub-modes keep Alt
+ * for placing a point freely.
+ */
+export function bindPaintPickHold(target: EventTarget): () => void {
+  let holding = false
+  const release = () => {
+    if (!holding) return
+    holding = false
+    endPaintPick()
+  }
+  const down = (event: Event) => {
+    const key = event as KeyboardEvent
+    if (key.key !== 'Alt' || key.repeat || holding || isTypingTarget(key.target)) return
+    if (usePaintRegionMode.getState().mode !== 'surface') return
+    key.preventDefault()
+    holding = true
+    usePaintRegionMode.getState().setMode('pick')
+  }
+  const up = (event: Event) => {
+    if ((event as KeyboardEvent).key === 'Alt') release()
+  }
+  // Escape leaves the eyedropper for the sub-mode it came from, not paint mode.
+  const onEscape = (event: Event) => {
+    const key = event as KeyboardEvent
+    if (key.key !== 'Escape' || !isPaintPicking() || isTypingTarget(key.target)) return
+    key.preventDefault()
+    key.stopPropagation()
+    holding = false
+    endPaintPick()
+  }
+  target.addEventListener('keydown', onEscape, true)
+  target.addEventListener('keydown', down)
+  target.addEventListener('keyup', up)
+  target.addEventListener('blur', release)
+  return () => {
+    target.removeEventListener('keydown', onEscape, true)
+    target.removeEventListener('keydown', down)
+    target.removeEventListener('keyup', up)
+    target.removeEventListener('blur', release)
+    release()
+  }
+}

package/src/lib/paint-regions.test.ts

@@ -0,0 +1,166 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNodeId,
+  clearSceneHistory,
+  useScene,
+  WALL_FACE_REGION_LIMIT,
+  WallNode,
+  ZoneNode,
+} from '@pascal-app/core'
+import { paintHints, paintRegionHints } from '../components/ui/helpers/helper-manager'
+import { paintRegionHovering } from './paint-region-hover'
+import { paintRegionModeActive, paintRegionTargets, usePaintRegionMode } from './paint-region-mode'
+import {
+  addFloorRegion,
+  addWallRegion,
+  removeWallRegion,
+  updateWallRegion,
+  WALL_REGION_CAP_MESSAGE,
+} from './paint-regions'
+import { snapContextOf } from './snapping-mode'
+
+const wall = WallNode.parse({ id: 'wall_regions', start: [0, 0], end: [4, 0], thickness: 0.2 })
+const zone = ZoneNode.parse({
+  id: 'zone_regions',
+  name: 'Room',
+  polygon: [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+  ],
+})
+const before = useScene.getState()
+beforeEach(() => {
+  useScene.setState({ nodes: { [wall.id]: wall, [zone.id]: zone }, materials: {}, readOnly: false })
+  useScene.temporal.getState().resume()
+  clearSceneHistory()
+})
+afterEach(() => {
+  useScene.setState(before)
+  usePaintRegionMode.getState().setMode('surface')
+})
+const node = (id: string) => useScene.getState().nodes[id as AnyNodeId] as never
+
+describe('paint regions', () => {
+  test('a wall region is one undo step, carries only the given bounds, and edits in place', () => {
+    const added = addWallRegion(wall.id, 'a', { v1: 0.9 }, { materialPreset: 'library:oak' })
+    expect(added.ok).toBe(true)
+    const regions = (node(wall.id) as WallNode).faceRegions!
+    expect(regions).toHaveLength(1)
+    expect(regions[0]).toMatchObject({ face: 'a', v1: 0.9, finish: 'library:oak' })
+    expect('u0' in regions[0]!).toBe(false)
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    const id = (added as { id: string }).id
+    expect(updateWallRegion(wall.id, id, { v0: 0.2, v1: 1.1 })).toBe(true)
+    expect((node(wall.id) as WallNode).faceRegions![0]).toMatchObject({ v0: 0.2, v1: 1.1 })
+    expect(removeWallRegion(wall.id, id)).toBe(true)
+    expect((node(wall.id) as WallNode).faceRegions).toBeUndefined()
+    expect(useScene.temporal.getState().pastStates).toHaveLength(3)
+  })
+
+  test('a one-off colour mints one scene material, reused by the next region', () => {
+    const material = { properties: { color: '#ff0000' } } as never
+    addWallRegion(wall.id, 'a', { v1: 0.9 }, { material })
+    addWallRegion(wall.id, 'b', { v0: 1 }, { material })
+    expect(Object.keys(useScene.getState().materials)).toHaveLength(1)
+    const [first, second] = (node(wall.id) as WallNode).faceRegions!
+    expect(first!.finish).toBe(second!.finish)
+    expect(addWallRegion(wall.id, 'a', {}, {})).toEqual({
+      ok: false,
+      message: 'Pick a material first',
+    })
+  })
+
+  test('a full face refuses the next region with the cap message', () => {
+    for (let i = 0; i < WALL_FACE_REGION_LIMIT; i++)
+      expect(
+        addWallRegion(wall.id, 'a', { u0: i * 0.4 }, { materialPreset: 'library:oak' }).ok,
+      ).toBe(true)
+    expect(addWallRegion(wall.id, 'a', { u0: 3.5 }, { materialPreset: 'library:oak' })).toEqual({
+      ok: false,
+      message: WALL_REGION_CAP_MESSAGE,
+    })
+    // The other face still has room.
+    expect(addWallRegion(wall.id, 'b', {}, { materialPreset: 'library:oak' }).ok).toBe(true)
+  })
+
+  test('a floor region lands on the room floor in one step', () => {
+    const square: [number, number][] = [
+      [1, 1],
+      [2, 1],
+      [2, 2],
+      [1, 2],
+    ]
+    expect(addFloorRegion(zone.id, square, { materialPreset: 'library:tile' }).ok).toBe(true)
+    expect((node(zone.id) as ZoneNode).floor?.regions).toEqual([
+      expect.objectContaining({ polygon: square, finish: 'library:tile' }),
+    ])
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    expect(addFloorRegion(zone.id, square.slice(0, 2), { materialPreset: 'library:tile' }).ok).toBe(
+      false,
+    )
+  })
+})
+
+describe('paint region sub-mode', () => {
+  test('owns the pointer and the snapping context only inside paint mode', () => {
+    expect(paintRegionModeActive('material-paint')).toBe(false)
+    usePaintRegionMode.getState().setMode('rectangle')
+    expect(paintRegionModeActive('material-paint')).toBe(true)
+    expect(paintRegionModeActive('select')).toBe(false)
+    const ctx = (mode: string) =>
+      snapContextOf({
+        scope: { kind: 'idle' },
+        mode,
+        tool: null,
+        profileOf: () => undefined,
+        paintRegion: true,
+      })
+    expect(ctx('material-paint')).toBe('polygon')
+    expect(ctx('select')).toBeNull()
+  })
+
+  test('each sub-mode names its surfaces and its HUD gesture', () => {
+    expect(paintRegionTargets('rectangle')).toEqual({ wall: true, floor: true })
+    expect(paintRegionTargets('polygon')).toEqual({ wall: false, floor: true })
+    expect(paintRegionHints('polygon', null).map((hint) => hint.keys[0])).toEqual([
+      'Left click',
+      'Backspace',
+      'Esc',
+    ])
+    expect(paintRegionHints('rectangle', WALL_REGION_CAP_MESSAGE)[0]).toMatchObject({
+      label: WALL_REGION_CAP_MESSAGE,
+      active: true,
+    })
+  })
+
+  test('off anything it draws on, the HUD says where to go: a floor for Polygon', () => {
+    expect(paintRegionHints('polygon', null, false).map((hint) => hint.label)).toEqual([
+      'Hover a floor or ceiling',
+      'Cancel',
+    ])
+    expect(paintRegionHints('rectangle', null, false)[0]).toMatchObject({
+      label: 'Hover a wall, floor or ceiling',
+      active: true,
+    })
+    expect(paintRegionHints('rectangle', null, true)[0]!.keys).toEqual(['Drag'])
+  })
+
+  test('the paint cursor is ready over what the sub-mode draws on, never blocked there', () => {
+    expect(paintRegionHovering('rectangle', { wall: true, floor: false })).toBe(true)
+    expect(paintRegionHovering('rectangle', { wall: false, floor: true })).toBe(true)
+    expect(paintRegionHovering('polygon', { wall: true, floor: false })).toBe(false)
+    expect(paintRegionHovering('polygon', { wall: false, floor: true })).toBe(true)
+    expect(paintRegionHovering('rectangle', { wall: false, floor: false })).toBe(false)
+  })
+})
+
+test('the whole-surface HUD says what a click does; only painting teaches the held eyedropper', () => {
+  const labels = (mode: Parameters<typeof paintHints>[0]) =>
+    paintHints(mode).map((hint) => hint.label)
+  expect(labels('surface')).toEqual(['Hold to pick a material'])
+  expect(labels('erase')).toEqual(['Remove a painted part, or reset a surface'])
+  expect(labels('erase').some((label) => /pick|colour|color|paint with/i.test(label))).toBe(false)
+  expect(labels('pick')).toEqual(['Paint with this material', 'Cancel'])
+})