@pascal-app/editor 0.9.1 → 0.9.2

package/src/lib/material-paint.ts

@@ -13,7 +13,6 @@ import {
   getEffectiveRoofSurfaceMaterial,
   getEffectiveSegmentSurfaceMaterial,
   getEffectiveStairSurfaceMaterial,
-  getEffectiveWallSurfaceMaterial,
   getLibraryMaterialIdFromRef,
   type MaterialSchema,
   type MaterialTarget,
@@ -26,28 +25,30 @@ import {
   type SlabNode,
   type StairNode,
   type StairSurfaceMaterialRole,
-  type WallNode,
   type WallSurfaceSide,
 } from '@pascal-app/core'
 
-export type PaintableMaterialTarget = Extract<
-  MaterialTarget,
-  | 'wall'
-  | 'roof'
-  | 'stair'
-  | 'fence'
-  | 'column'
-  | 'slab'
-  | 'ceiling'
-  | 'shelf'
-  | 'chimney'
-  | 'dormer'
-  | 'box-vent'
-  | 'ridge-vent'
-  | 'turbine-vent'
-  | 'cupola'
-  | 'eyebrow-vent'
->
+export type PaintableMaterialTarget =
+  | Extract<
+      MaterialTarget,
+      | 'wall'
+      | 'roof'
+      | 'stair'
+      | 'fence'
+      | 'column'
+      | 'slab'
+      | 'ceiling'
+      | 'shelf'
+      | 'cabinet'
+      | 'chimney'
+      | 'dormer'
+      | 'box-vent'
+      | 'ridge-vent'
+      | 'turbine-vent'
+      | 'cupola'
+      | 'eyebrow-vent'
+    >
+  | 'item'
 
 export type SingleSurfaceMaterialRole = 'surface'
 
@@ -76,32 +77,6 @@ export function getActivePaintMaterialLabel(material: ActivePaintMaterial | null
   return getCatalogEntryForActivePaintMaterial(material)?.label ?? 'Custom'
 }
 
-export function buildWallSurfaceMaterialPatch(
-  node: WallNode,
-  targetSide: WallSurfaceSide,
-  material: MaterialSchema | undefined,
-  materialPreset: string | undefined,
-): Partial<WallNode> {
-  const nextSurfaceMaterial = { material, materialPreset }
-  const nextInterior =
-    targetSide === 'interior'
-      ? nextSurfaceMaterial
-      : getEffectiveWallSurfaceMaterial(node, 'interior')
-  const nextExterior =
-    targetSide === 'exterior'
-      ? nextSurfaceMaterial
-      : getEffectiveWallSurfaceMaterial(node, 'exterior')
-
-  return {
-    interiorMaterial: nextInterior.material,
-    interiorMaterialPreset: nextInterior.materialPreset,
-    exteriorMaterial: nextExterior.material,
-    exteriorMaterialPreset: nextExterior.materialPreset,
-    material: undefined,
-    materialPreset: undefined,
-  }
-}
-
 export function buildRoofSurfaceMaterialPatch(
   node: RoofNode,
   targetRole: RoofSurfaceMaterialRole,
@@ -179,6 +154,7 @@ export function buildResetSurfaceMaterialUpdates(
       if (
         key === 'material' ||
         key === 'materialPreset' ||
+        key === 'slots' ||
         key.endsWith('Material') ||
         key.endsWith('MaterialPreset')
       ) {
@@ -276,6 +252,7 @@ export function resolveActivePaintMaterialFromSelection(params: {
       | ChimneyMaterialRole
       | DormerSurfaceMaterialRole
       | SingleSurfaceMaterialRole
+      | string
   } | null
 }): ActivePaintMaterial | null {
   const { nodes, selectedId, selectedMaterialTarget } = params
@@ -297,7 +274,7 @@ export function resolveActivePaintMaterialFromSelection(params: {
       nodes,
     })
     if (surface) {
-      const sourceTarget = selectedNode.type as PaintableMaterialTarget
+      const sourceTarget = (paintCap.materialTarget ?? selectedNode.type) as PaintableMaterialTarget
       return hasActivePaintMaterial({
         material: surface.material,
         materialPreset: surface.materialPreset,
@@ -375,11 +352,13 @@ export function resolveActivePaintMaterialFromSelection(params: {
   // Wall / chimney / dormer flow through the registry-driven path
   // at the top of this function.
 
+  // Slot-backed kinds resolve via the registry-driven `getEffectiveMaterial`
+  // path at the top of this function, including legacy inline-material
+  // fallbacks when their capability exposes one.
+
   if (
     (selectedNode.type === 'fence' ||
       selectedNode.type === 'column' ||
-      selectedNode.type === 'slab' ||
-      selectedNode.type === 'ceiling' ||
       selectedNode.type === 'shelf') &&
     selectedMaterialTarget.role === 'surface'
   ) {
@@ -412,6 +391,10 @@ export function resolvePaintTargetFromSelection(params: {
   const selectedNode = nodes[selectedId]
   if (!selectedNode) return null
 
+  const registryPaintTarget = nodeRegistry.get(selectedNode.type)?.capabilities?.paint
+    ?.materialTarget
+  if (registryPaintTarget) return registryPaintTarget as PaintableMaterialTarget
+
   if (selectedNode.type === 'wall') {
     return 'wall'
   }
@@ -444,6 +427,10 @@ export function resolvePaintTargetFromSelection(params: {
     return 'shelf'
   }
 
+  if (selectedNode.type === 'item') {
+    return 'item'
+  }
+
   if (selectedNode.type === 'chimney') {
     return 'chimney'
   }

package/src/lib/measurement-kind.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  CREATABLE_MEASUREMENT_KINDS,
+  DEFAULT_CREATABLE_MEASUREMENT_KIND,
+  normalizeCreatableMeasurementKind,
+} from './measurement-kind'
+
+describe('creatable measurement kinds', () => {
+  test('keeps the supported creation kinds', () => {
+    expect(CREATABLE_MEASUREMENT_KINDS).toEqual([
+      'distance',
+      'angle',
+      'area',
+      'perimeter',
+      'volume',
+    ])
+    for (const kind of CREATABLE_MEASUREMENT_KINDS) {
+      expect(normalizeCreatableMeasurementKind(kind)).toBe(kind)
+    }
+  })
+
+  test.each([
+    'smart',
+    'unknown',
+    null,
+    undefined,
+  ])('falls back from a non-creatable persisted value: %s', (value) => {
+    expect(normalizeCreatableMeasurementKind(value)).toBe(DEFAULT_CREATABLE_MEASUREMENT_KIND)
+  })
+})

package/src/lib/measurement-kind.ts

@@ -0,0 +1,19 @@
+export const CREATABLE_MEASUREMENT_KINDS = [
+  'distance',
+  'angle',
+  'area',
+  'perimeter',
+  'volume',
+] as const
+
+export type CreatableMeasurementKind = (typeof CREATABLE_MEASUREMENT_KINDS)[number]
+
+export const DEFAULT_CREATABLE_MEASUREMENT_KIND: CreatableMeasurementKind = 'distance'
+
+export function isCreatableMeasurementKind(value: unknown): value is CreatableMeasurementKind {
+  return CREATABLE_MEASUREMENT_KINDS.includes(value as CreatableMeasurementKind)
+}
+
+export function normalizeCreatableMeasurementKind(value: unknown): CreatableMeasurementKind {
+  return isCreatableMeasurementKind(value) ? value : DEFAULT_CREATABLE_MEASUREMENT_KIND
+}

package/src/lib/measurement-label.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+import { measurementCentroid, pointInPolygon2D } from '@pascal-app/core'
+import { measurementPolygonLabelAnchor, triangulateMeasurementPolygon } from './measurement-label'
+
+describe('measurementPolygonLabelAnchor', () => {
+  test('keeps a concave polygon label inside its visible fill', () => {
+    const base = [
+      [0, 0, 0],
+      [4, 0, 0],
+      [4, 0, 1],
+      [1, 0, 1],
+      [1, 0, 4],
+      [0, 0, 4],
+    ] as [number, number, number][]
+    const centroid = measurementCentroid(base)
+    const anchor = measurementPolygonLabelAnchor(base)
+
+    expect(centroid).not.toBeNull()
+    expect(
+      pointInPolygon2D(
+        [centroid![0], centroid![2]],
+        base.map(([x, , z]) => [x, z]),
+      ),
+    ).toBe(false)
+    expect(anchor).not.toBeNull()
+    expect(
+      pointInPolygon2D(
+        [anchor![0], anchor![2]],
+        base.map(([x, , z]) => [x, z]),
+      ),
+    ).toBe(true)
+  })
+
+  test('returns an on-plane anchor for a sloped polygon', () => {
+    const base = [
+      [0, 0, 0],
+      [4, 2, 0],
+      [4, 2, 4],
+      [0, 0, 4],
+    ] as [number, number, number][]
+    const anchor = measurementPolygonLabelAnchor(base)
+
+    expect(triangulateMeasurementPolygon(base)).toHaveLength(2)
+    expect(anchor).not.toBeNull()
+    expect(anchor![1]).toBeCloseTo(anchor![0] / 2)
+  })
+})

package/src/lib/measurement-label.ts

@@ -0,0 +1,68 @@
+import { type MeasurementPoint, measurementCentroid, measurementNormal } from '@pascal-app/core'
+import { ShapeUtils, Vector2, Vector3 } from 'three'
+
+type MeasurementPolygonProjection = {
+  contour: Vector2[]
+  triangles: number[][]
+}
+
+function projectMeasurementPolygon(
+  points: readonly MeasurementPoint[],
+): MeasurementPolygonProjection | null {
+  const normalValue = measurementNormal(points)
+  const originValue = points[0]
+  if (!(normalValue && originValue)) return null
+
+  const normal = new Vector3(...normalValue)
+  const reference = Math.abs(normal.y) < 0.9 ? new Vector3(0, 1, 0) : new Vector3(1, 0, 0)
+  const tangent = new Vector3().crossVectors(reference, normal).normalize()
+  const bitangent = new Vector3().crossVectors(normal, tangent).normalize()
+  const origin = new Vector3(...originValue)
+  const contour = points.map((point) => {
+    const relative = new Vector3(...point).sub(origin)
+    return new Vector2(relative.dot(tangent), relative.dot(bitangent))
+  })
+
+  return { contour, triangles: ShapeUtils.triangulateShape(contour, []) }
+}
+
+export function triangulateMeasurementPolygon(points: readonly MeasurementPoint[]): number[][] {
+  return projectMeasurementPolygon(points)?.triangles ?? []
+}
+
+export function measurementPolygonLabelAnchor(
+  points: readonly MeasurementPoint[],
+): MeasurementPoint | null {
+  const projection = projectMeasurementPolygon(points)
+  if (!projection || projection.triangles.length === 0) return measurementCentroid(points)
+
+  let largestTriangle: number[] | null = null
+  let largestArea = Number.NEGATIVE_INFINITY
+  for (const triangle of projection.triangles) {
+    const [firstIndex, secondIndex, thirdIndex] = triangle
+    const first = firstIndex === undefined ? null : projection.contour[firstIndex]
+    const second = secondIndex === undefined ? null : projection.contour[secondIndex]
+    const third = thirdIndex === undefined ? null : projection.contour[thirdIndex]
+    if (!(first && second && third)) continue
+    const area = Math.abs(
+      (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x),
+    )
+    if (area > largestArea) {
+      largestArea = area
+      largestTriangle = triangle
+    }
+  }
+
+  if (!largestTriangle) return measurementCentroid(points)
+  const [firstIndex, secondIndex, thirdIndex] = largestTriangle
+  const first = firstIndex === undefined ? null : points[firstIndex]
+  const second = secondIndex === undefined ? null : points[secondIndex]
+  const third = thirdIndex === undefined ? null : points[thirdIndex]
+  if (!(first && second && third)) return measurementCentroid(points)
+
+  return [
+    (first[0] + second[0] + third[0]) / 3,
+    (first[1] + second[1] + third[1]) / 3,
+    (first[2] + second[2] + third[2]) / 3,
+  ]
+}

package/src/lib/measurement-parser.ts

@@ -0,0 +1,116 @@
+import { type Kind, parseQuantity, quantity } from '@pascal-app/lingo'
+
+/**
+ * Natural-language measurement parsing for editor property fields, backed by
+ * `@pascal-app/lingo`. Lets a user type `6ft`, `180cm`, `1m80`, `5'11"`, `45°`
+ * or `1.57rad` into any measurement field and have it canonicalized to the
+ * unit the field stores its value in — independent of the metric/imperial
+ * display toggle.
+ *
+ * The editor stores linear values in meters and angular values in radians (a
+ * few fields store inches or degrees); lingo's `length` base is meters and its
+ * `angle` base is radians, so a field's `unit` prop already names the stored /
+ * canonical unit and doubles as the parse target.
+ */
+
+export interface LingoUnitSpec {
+  kind: Kind
+  /** Unit id the field's stored `value` is expressed in — the parse target. */
+  unitId: string
+}
+
+/**
+ * Map an editor field `unit` prop to a lingo kind + canonical unit. Returns
+ * `null` for units we deliberately do NOT natural-language-parse (plain
+ * numbers, percentages, angular rates, counts) so those keep exact
+ * `Number.parseFloat` behavior.
+ */
+export function lingoUnitSpec(unit: string | undefined): LingoUnitSpec | null {
+  switch (unit) {
+    case 'm':
+    case 'cm':
+    case 'mm':
+    case 'in':
+    case 'ft':
+      return { kind: 'length', unitId: unit }
+    case '°':
+    case 'deg':
+    case 'degrees':
+      return { kind: 'angle', unitId: 'deg' }
+    case 'rad':
+    case 'radians':
+      return { kind: 'angle', unitId: 'rad' }
+    default:
+      return null
+  }
+}
+
+export interface ParseMeasurementOptions {
+  /**
+   * Implied unit for a BARE number (e.g. `6` → `6 ft`). Defaults to the field's
+   * own `unitId`. A typed unit (`180cm`) is always honored regardless.
+   */
+  bareUnit?: string
+  /** Disambiguates gal/ton/cup families; harmless for length/angle. */
+  system?: 'metric' | 'us' | 'imperial'
+}
+
+/**
+ * Parse typed field text into the field's stored numeric unit. Returns `null`
+ * when the text can't be read as a quantity, so the caller can fall back to a
+ * plain number parse or revert to the previous value.
+ */
+export function parseMeasurement(
+  raw: string,
+  spec: LingoUnitSpec,
+  options: ParseMeasurementOptions = {},
+): number | null {
+  const result = parseQuantity(raw, {
+    kind: spec.kind,
+    unit: options.bareUnit ?? spec.unitId,
+    system: options.system,
+    strictness: 'forgiving',
+  })
+  if (!result.ok) return null
+  const value = result.quantity.to(spec.unitId).value
+  return Number.isFinite(value) ? value : null
+}
+
+export interface MeasurementHintOptions extends ParseMeasurementOptions {
+  /** Unit id the preview is rendered in (the field's displayed unit). */
+  displayUnit?: string
+  /** Max fraction digits in the preview. */
+  precision?: number
+  /**
+   * Clamp applied to the parsed stored value before previewing, so the hint
+   * reflects what a commit would actually store on a bounded field.
+   */
+  clamp?: (stored: number) => number
+}
+
+const PLAIN_NUMBER = /^[+-]?\d*\.?\d*$/
+
+/**
+ * A faint "= 1.83 m" preview of the value currently being typed, shown only
+ * when the user typed something beyond a plain decimal in the field's own unit
+ * (an explicit unit, a compound like `1m80`, or a number word) and it parses.
+ * Returns `null` when there's nothing useful to preview.
+ */
+export function measurementHint(
+  raw: string,
+  spec: LingoUnitSpec,
+  options: MeasurementHintOptions = {},
+): string | null {
+  const trimmed = raw.trim()
+  if (!trimmed || PLAIN_NUMBER.test(trimmed)) return null
+
+  const parsed = parseMeasurement(trimmed, spec, options)
+  if (parsed === null) return null
+  const stored = options.clamp ? options.clamp(parsed) : parsed
+
+  const displayUnit = options.displayUnit ?? spec.unitId
+  const precision = options.precision ?? 2
+  const q = quantity(stored, spec.unitId)
+  const shown = displayUnit === spec.unitId ? q : q.to(displayUnit)
+  return `= ${shown.format({ precision })}`
+}

package/src/lib/measurements.test.ts

@@ -0,0 +1,183 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  buildMeasurementAngleArcPoints,
+  cubicMetersToVolumeUnit,
+  formatAreaLabel,
+  formatLinearMeasurement,
+  formatVolumeLabel,
+  getAreaUnitLabel,
+  getLinearUnitLabel,
+  getVolumeUnitLabel,
+  linearControlValueToMeters,
+  linearUnitToMeters,
+  MEASUREMENT_ACTIVE_COLOR,
+  MEASUREMENT_DANGLING_COLOR,
+  MEASUREMENT_FLOORPLAN_COLOR,
+  MEASUREMENT_PERSISTENT_COLOR,
+  measurementFloorplanPresentationColor,
+  measurementPresentationColor,
+  metersToLinearUnit,
+  squareMetersToAreaUnit,
+} from './measurements'
+
+describe('measurement presentation', () => {
+  test('uses black at rest, indigo while active, and red for dangling references', () => {
+    expect(measurementPresentationColor(false, false)).toBe(MEASUREMENT_PERSISTENT_COLOR)
+    expect(measurementPresentationColor(false, true)).toBe(MEASUREMENT_ACTIVE_COLOR)
+    expect(measurementPresentationColor(true, false)).toBe(MEASUREMENT_DANGLING_COLOR)
+    expect(measurementPresentationColor(true, true)).toBe(MEASUREMENT_DANGLING_COLOR)
+  })
+
+  test('uses an indigo analysis color for resting 2D measurements', () => {
+    expect(measurementFloorplanPresentationColor(false, false)).toBe(MEASUREMENT_FLOORPLAN_COLOR)
+    expect(measurementFloorplanPresentationColor(false, true)).toBe(MEASUREMENT_ACTIVE_COLOR)
+    expect(measurementFloorplanPresentationColor(true, false)).toBe(MEASUREMENT_DANGLING_COLOR)
+  })
+})
+
+describe('angle arc presentation', () => {
+  test('samples the smaller angle from the first ray to the second', () => {
+    const arc = buildMeasurementAngleArcPoints([1, 0, 0], [0, 0, 0], [0, 0, 1], {
+      radius: 0.25,
+      sampleCount: 8,
+    })
+
+    expect(arc).toHaveLength(9)
+    expect(arc[0]?.[0]).toBeCloseTo(0.25)
+    expect(arc[0]?.[2]).toBeCloseTo(0)
+    expect(arc.at(-1)?.[0]).toBeCloseTo(0)
+    expect(arc.at(-1)?.[2]).toBeCloseTo(0.25)
+    expect(arc[4]?.[0]).toBeGreaterThan(0)
+    expect(arc[4]?.[2]).toBeGreaterThan(0)
+  })
+
+  test('keeps a constant radius on an arbitrary 3D angle plane', () => {
+    const arc = buildMeasurementAngleArcPoints([1, 0, 0], [0, 0, 0], [0, 1, 0], {
+      radius: 0.3,
+    })
+
+    expect(arc.length).toBeGreaterThan(4)
+    for (const point of arc) expect(Math.hypot(...point)).toBeCloseTo(0.3)
+    expect(arc.at(-1)?.[1]).toBeCloseTo(0.3)
+  })
+
+  test('omits an arc when either ray is degenerate', () => {
+    expect(buildMeasurementAngleArcPoints([0, 0, 0], [0, 0, 0], [1, 0, 0])).toEqual([])
+  })
+})
+
+describe('linear measurements', () => {
+  test('formats metric measurements in meters', () => {
+    expect(formatLinearMeasurement(3, 'metric')).toBe('3m')
+    expect(formatLinearMeasurement(3.456, 'metric')).toBe('3.46m')
+  })
+
+  test('formats imperial measurements as feet and inches', () => {
+    expect(formatLinearMeasurement(3.048, 'imperial')).toBe(`10'0"`)
+    expect(formatLinearMeasurement(3.2004, 'imperial')).toBe(`10'6"`)
+  })
+
+  test('carries rounded 12 inches into the next foot', () => {
+    expect(formatLinearMeasurement(3.047, 'imperial')).toBe(`10'0"`)
+  })
+
+  test('returns a placeholder for non-finite measurements', () => {
+    expect(formatLinearMeasurement(NaN, 'imperial')).toBe('--')
+    expect(formatLinearMeasurement(Infinity, 'imperial')).toBe('--')
+    expect(formatLinearMeasurement(NaN, 'metric')).toBe('--')
+  })
+
+  test('formats zero measurements', () => {
+    expect(formatLinearMeasurement(0, 'imperial')).toBe(`0'0"`)
+    expect(formatLinearMeasurement(0, 'metric')).toBe('0m')
+  })
+
+  test('formats sub-foot imperial measurements', () => {
+    expect(formatLinearMeasurement(0.1524, 'imperial')).toBe(`0'6"`)
+  })
+
+  test('formats negative measurements with a sign', () => {
+    expect(formatLinearMeasurement(-0.1524, 'imperial')).toBe(`-0'6"`)
+    expect(formatLinearMeasurement(-0.1524, 'metric')).toBe('-0.15m')
+  })
+
+  test('converts between meters and the active linear unit', () => {
+    expect(metersToLinearUnit(0, 'imperial')).toBe(0)
+    expect(linearUnitToMeters(0, 'imperial')).toBe(0)
+
+    expect(metersToLinearUnit(1, 'metric')).toBe(1)
+    expect(linearUnitToMeters(1, 'metric')).toBe(1)
+
+    expect(metersToLinearUnit(0.3048, 'imperial')).toBeCloseTo(1)
+    expect(linearUnitToMeters(1, 'imperial')).toBeCloseTo(0.3048)
+  })
+
+  test('converts numeric control input back to meters for wall panel edits', () => {
+    expect(linearControlValueToMeters(10, 'imperial')).toBeCloseTo(3.048)
+    expect(linearControlValueToMeters(0.5, 'imperial')).toBeCloseTo(0.1524)
+    expect(linearControlValueToMeters(-1, 'imperial')).toBeCloseTo(-0.3048)
+    expect(linearControlValueToMeters(3.5, 'metric')).toBe(3.5)
+  })
+
+  test('clamps numeric control input after converting to meters', () => {
+    expect(linearControlValueToMeters(0.1, 'imperial', { minMeters: 0.1 })).toBe(0.1)
+    expect(linearControlValueToMeters(0.3, 'imperial', { minMeters: 0.1 })).toBe(0.1)
+    expect(linearControlValueToMeters(19.7, 'imperial', { maxMeters: 6 })).toBe(6)
+    expect(linearControlValueToMeters(0.2, 'metric', { minMeters: 0.1 })).toBe(0.2)
+    expect(linearControlValueToMeters(0.2, 'metric', { maxMeters: 0.15 })).toBe(0.15)
+  })
+
+  test('returns the display label for numeric controls', () => {
+    expect(getLinearUnitLabel('metric')).toBe('m')
+    expect(getLinearUnitLabel('imperial')).toBe('ft')
+  })
+})
+
+describe('area measurements', () => {
+  test('converts square meters to the active area unit', () => {
+    expect(squareMetersToAreaUnit(0, 'imperial')).toBe(0)
+    expect(squareMetersToAreaUnit(12.5, 'metric')).toBe(12.5)
+    expect(squareMetersToAreaUnit(1, 'imperial')).toBeCloseTo(10.7639)
+  })
+
+  test('returns the display label for area readouts', () => {
+    expect(getAreaUnitLabel('metric')).toBe('m²')
+    expect(getAreaUnitLabel('imperial')).toBe('ft²')
+  })
+
+  test('formats an area label with value and unit', () => {
+    expect(formatAreaLabel(12.34, 'metric')).toBe('12.3m²')
+    expect(formatAreaLabel(1, 'imperial')).toBe('10.8ft²')
+    expect(formatAreaLabel(12.34, 'metric', 2)).toBe('12.34m²')
+  })
+
+  test('returns a placeholder for non-finite areas', () => {
+    expect(formatAreaLabel(NaN, 'metric')).toBe('--')
+    expect(formatAreaLabel(Infinity, 'imperial')).toBe('--')
+  })
+})
+
+describe('volume measurements', () => {
+  test('converts cubic meters to the active volume unit', () => {
+    expect(cubicMetersToVolumeUnit(0, 'imperial')).toBe(0)
+    expect(cubicMetersToVolumeUnit(12.5, 'metric')).toBe(12.5)
+    expect(cubicMetersToVolumeUnit(1, 'imperial')).toBeCloseTo(35.3147)
+  })
+
+  test('returns the display label for volume readouts', () => {
+    expect(getVolumeUnitLabel('metric')).toBe('m³')
+    expect(getVolumeUnitLabel('imperial')).toBe('ft³')
+  })
+
+  test('formats a volume label with value and unit', () => {
+    expect(formatVolumeLabel(12.34, 'metric')).toBe('12.3m³')
+    expect(formatVolumeLabel(1, 'imperial')).toBe('35.3ft³')
+    expect(formatVolumeLabel(12.34, 'metric', 2)).toBe('12.34m³')
+  })
+
+  test('returns a placeholder for non-finite volumes', () => {
+    expect(formatVolumeLabel(NaN, 'metric')).toBe('--')
+    expect(formatVolumeLabel(Infinity, 'imperial')).toBe('--')
+    expect(formatVolumeLabel(Number.NEGATIVE_INFINITY, 'metric')).toBe('--')
+  })
+})