@pascal-app/editor 1.0.4 → 1.0.6

package/src/lib/point-ask/describe-target.test.ts

@@ -0,0 +1,165 @@
+import { describe, expect, test } from 'bun:test'
+import type { AnyNode } from '@pascal-app/core'
+import { house } from './__fixtures__/house'
+import { describeTarget } from './describe-target'
+
+// Point and ask names what the finger is on, in the viewer's unit, for the label chip and the
+// bubble's context row, and in metres for the agent (the context's `size`). Written first: a size
+// in the wrong unit; a wall that does not say which room it bounds; a window's sill missing from the
+// context; an element of a kind nobody described showing no name at all.
+
+const nodes = house()
+const metric = { unit: 'metric' } as const
+const at = (id: string, unit: Parameters<typeof describeTarget>[2] = metric) =>
+  describeTarget(nodes[id] as AnyNode, nodes, unit)
+
+describe('a room', () => {
+  test('is named by its zone, sized by its area, and is the kind "room"', () => {
+    const room = at('zone_kitchen')
+
+    expect(room).toMatchObject({
+      id: 'zone_kitchen',
+      type: 'zone',
+      kind: 'room',
+      name: 'Kitchen',
+      size: '12.0 m²',
+      levelId: 'level_0',
+    })
+    expect(room.sizes).toEqual({ area: 12, width: 4, depth: 3 })
+    expect(room.zoneId).toBeUndefined()
+  })
+
+  test('a room with no name is "Room"', () => {
+    const unnamed = { ...nodes.zone_kitchen, name: '' } as AnyNode
+
+    expect(describeTarget(unnamed, { ...nodes, zone_kitchen: unnamed }, metric).name).toBe('Room')
+  })
+})
+
+describe('a wall', () => {
+  test('says which room it bounds, its length by its height, and the room it is in', () => {
+    const wall = at('wall_north')
+
+    expect(wall).toMatchObject({ kind: 'wall', name: 'Wall · Kitchen', zoneId: 'zone_kitchen' })
+    expect(wall.sizes.length).toBeCloseTo(4, 6)
+    expect(wall.sizes.thickness).toBeGreaterThan(0)
+    expect(wall.size).toBe(`4.00 × ${wall.sizes.height!.toFixed(2)} m`)
+  })
+
+  test('a wall bounding no room is just "Wall"', () => {
+    const { zone_kitchen: _gone, ...without } = nodes
+    const wall = describeTarget(nodes.wall_north as AnyNode, without as typeof nodes, metric)
+
+    expect(wall.name).toBe('Wall')
+    expect(wall.zoneId).toBeUndefined()
+  })
+})
+
+describe('a window and a door', () => {
+  test('a window: width by height, its sill in the context, its wall as parent', () => {
+    const window = at('window_north')
+
+    expect(window).toMatchObject({
+      kind: 'window',
+      name: 'Window',
+      size: '1.20 × 1.40 m',
+      parentId: 'wall_north',
+      zoneId: 'zone_kitchen',
+    })
+    expect(window.sizes.width).toBeCloseTo(1.2, 6)
+    expect(window.sizes.height).toBeCloseTo(1.4, 6)
+    expect(window.sizes.sill).toBeCloseTo(0.7, 6)
+  })
+
+  test('a door stands on the floor: sill 0', () => {
+    const door = at('door_front')
+
+    expect(door).toMatchObject({ kind: 'door', name: 'Door', size: '0.90 × 2.10 m' })
+    expect(door.sizes.sill).toBeCloseTo(0, 6)
+  })
+})
+
+describe('an item', () => {
+  test('is named by the person’s name, sized by its width, and sits in the room it stands in', () => {
+    const sofa = at('item_sofa')
+
+    expect(sofa).toMatchObject({
+      kind: 'item',
+      name: 'Sofa',
+      size: '2.10 m wide',
+      zoneId: 'zone_kitchen',
+    })
+    expect(sofa.parentId).toBeUndefined()
+    expect(sofa.sizes).toEqual({ width: 2.1, depth: 0.95, height: 0.85 })
+  })
+
+  test('with no name it is the asset’s, and then just "Item"', () => {
+    const unnamed = { ...nodes.item_sofa, name: undefined } as AnyNode
+    expect(describeTarget(unnamed, nodes, metric).name).toBe('Oslo 3-seat')
+
+    const bare = {
+      ...nodes.item_sofa,
+      name: undefined,
+      asset: { ...(nodes.item_sofa as never as { asset: object }).asset, name: '' },
+    } as AnyNode
+    expect(describeTarget(bare, nodes, metric).name).toBe('Item')
+  })
+})
+
+describe('units', () => {
+  test('imperial reads in feet, inches and square feet', () => {
+    const imperial = { unit: 'imperial' } as const
+
+    expect(at('zone_kitchen', imperial).size).toBe('129.2 ft²')
+    expect(at('window_north', imperial).size).toBe(`3'11" × 4'7"`)
+    expect(at('item_sofa', imperial).size).toBe(`6'11" wide`)
+    // The context stays in metres whatever the viewer shows.
+    expect(at('window_north', imperial).sizes.width).toBeCloseTo(1.2, 6)
+  })
+
+  test('millimetres when the viewer shows them', () => {
+    const mm = { unit: 'metric', metricNotation: 'millimeters' } as const
+
+    expect(at('window_north', mm).size).toBe('1200 × 1400 mm')
+    expect(at('item_sofa', mm).size).toBe('2100 mm wide')
+  })
+})
+
+describe('everything else', () => {
+  test('a kind nobody described still has a name and a type', () => {
+    const odd = {
+      id: 'column_1',
+      type: 'column',
+      parentId: 'level_0',
+      name: 'Pillar',
+    } as unknown as AnyNode
+    const anonymous = { id: 'fence_1', type: 'fence', parentId: 'level_0' } as unknown as AnyNode
+
+    expect(describeTarget(odd, { ...nodes, column_1: odd }, metric)).toMatchObject({
+      kind: 'other',
+      name: 'Pillar',
+      type: 'column',
+    })
+    expect(describeTarget(anonymous, { ...nodes, fence_1: anonymous }, metric).name).toBe('Fence')
+  })
+
+  test('a roof segment is the kind "roof" and a stair the kind "stair"', () => {
+    const segment = {
+      id: 'roof_segment_1',
+      type: 'roof-segment',
+      parentId: 'roof_1',
+      width: 8,
+      depth: 6,
+    } as unknown as AnyNode
+    const stair = {
+      id: 'stair_1',
+      type: 'stair',
+      parentId: 'level_0',
+      width: 1,
+      totalRise: 2.7,
+    } as unknown as AnyNode
+
+    expect(describeTarget(segment, nodes, metric).kind).toBe('roof')
+    expect(describeTarget(stair, nodes, metric).kind).toBe('stair')
+  })
+})

package/src/lib/point-ask/describe-target.ts

@@ -0,0 +1,234 @@
+import {
+  type AnyNode,
+  area,
+  getScaledDimensions,
+  getWallCurveLength,
+  getWallEffectiveHeightForNodes,
+  getWallThickness,
+  type ItemNode,
+  resolveLevelId,
+  type SlabNode,
+  type StairNode,
+  type WallNode,
+  type WindowNode,
+  type ZoneNode,
+} from '@pascal-app/core'
+import {
+  formatLinearMeasurement,
+  getAreaUnitLabel,
+  type LinearUnit,
+  type MetricNotation,
+  squareMetersToAreaUnit,
+} from '../measurements'
+import type { PointKind, PointTarget } from './types'
+
+// Point and ask names what the finger is on (the owner, 8 October): the label chip and the
+// bubble's context row read it in the viewer's unit; the agent reads the same element's `sizes` in
+// metres. Pure: the scene is handed in.
+
+export type PointUnit = { unit: LinearUnit; metricNotation?: MetricNotation }
+
+/** A described element: the chip's fields, plus what the agent's context carries. */
+export type DescribedTarget = PointTarget & {
+  levelId: string
+  /** The room it is in or bounds. */
+  zoneId?: string
+  /** The wall an opening is in, the item an item stands on. */
+  parentId?: string
+  /** Metres: wall {length, height, thickness}; zone {area, width, depth}; window/door {width,
+   *  height, sill}; item {width, depth, height}. */
+  sizes: Record<string, number>
+}
+
+type Nodes = Readonly<Record<string, AnyNode | undefined>>
+
+const KINDS: Partial<Record<string, PointKind>> = {
+  zone: 'room',
+  wall: 'wall',
+  window: 'window',
+  door: 'door',
+  item: 'item',
+  roof: 'roof',
+  'roof-segment': 'roof',
+  stair: 'stair',
+  'stair-segment': 'stair',
+}
+
+const DEFAULT_NAMES: Partial<Record<string, string>> = {
+  slab: 'Floor',
+  ceiling: 'Ceiling',
+}
+
+const sentence = (type: string) => {
+  const words = type.replace(/-/g, ' ')
+  return words.charAt(0).toUpperCase() + words.slice(1)
+}
+
+const metres = (value: number, unit: PointUnit) => {
+  if (unit.unit === 'imperial') return formatLinearMeasurement(value, 'imperial')
+  return unit.metricNotation === 'millimeters' ? `${Math.round(value * 1000)}` : value.toFixed(2)
+}
+
+/** "4.80 × 2.70 m", "3'11" × 4'7"", "1200 × 1400 mm". */
+function dimensions(values: number[], unit: PointUnit): string {
+  const parts = values.map((value) => metres(value, unit)).join(' × ')
+  if (unit.unit === 'imperial') return parts
+  return `${parts} ${unit.metricNotation === 'millimeters' ? 'mm' : 'm'}`
+}
+
+/** "2.10 m wide". */
+function wide(value: number, unit: PointUnit): string {
+  return `${dimensions([value], unit)} wide`
+}
+
+function areaLabel(squareMetres: number, unit: PointUnit): string {
+  return `${squareMetersToAreaUnit(squareMetres, unit.unit).toFixed(1)} ${getAreaUnitLabel(unit.unit)}`
+}
+
+function extent(points: readonly (readonly number[])[], axis: 0 | 1): number {
+  const values = points.map((point) => point[axis]!)
+  return values.length ? Math.max(...values) - Math.min(...values) : 0
+}
+
+function insidePolygon(point: readonly [number, number], polygon: readonly (readonly number[])[]) {
+  let inside = false
+  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+    const [xi, zi] = [polygon[i]![0]!, polygon[i]![1]!]
+    const [xj, zj] = [polygon[j]![0]!, polygon[j]![1]!]
+    if (
+      zi > point[1] !== zj > point[1] &&
+      point[0] < ((xj - xi) * (point[1] - zi)) / (zj - zi) + xi
+    )
+      inside = !inside
+  }
+  return inside
+}
+
+const zonesOf = (nodes: Nodes, levelId: string) =>
+  Object.values(nodes).filter(
+    (node): node is ZoneNode => node?.type === 'zone' && node.parentId === levelId,
+  )
+
+/** The room a wall bounds: the zone that lists it among its boundary walls. */
+const roomOfWall = (nodes: Nodes, levelId: string, wallId: string) =>
+  zonesOf(nodes, levelId).find((zone) => zone.boundaryWallIds?.includes(wallId as never))
+
+function wallHeight(wall: WallNode, nodes: Nodes): number {
+  try {
+    const height = getWallEffectiveHeightForNodes(wall, nodes as Record<string, AnyNode>)
+    if (Number.isFinite(height) && height > 0) return height
+  } catch {
+    // No slab election to consult in a bare scene: the wall's own height stands.
+  }
+  return wall.height ?? 2.5
+}
+
+export function describeTarget(node: AnyNode, nodes: Nodes, unit: PointUnit): DescribedTarget {
+  const levelId = resolveLevelId(node, nodes as Record<string, AnyNode>)
+  const named = (fallback: string) => (node as { name?: string }).name?.trim() || fallback
+  const base = {
+    id: node.id,
+    type: node.type,
+    kind: KINDS[node.type] ?? ('other' as PointKind),
+    levelId,
+  }
+
+  if (node.type === 'zone') {
+    const zone = node as ZoneNode
+    const squareMetres = area([{ outer: zone.polygon, holes: zone.holes }])
+    return {
+      ...base,
+      name: named('Room'),
+      size: areaLabel(squareMetres, unit),
+      sizes: {
+        area: squareMetres,
+        width: extent(zone.polygon, 0),
+        depth: extent(zone.polygon, 1),
+      },
+    }
+  }
+
+  if (node.type === 'wall') {
+    const wall = node as WallNode
+    const room = roomOfWall(nodes, levelId, wall.id)
+    const length = getWallCurveLength(wall)
+    const height = wallHeight(wall, nodes)
+    return {
+      ...base,
+      name: named(room ? `Wall · ${room.name?.trim() || 'Room'}` : 'Wall'),
+      size: dimensions([length, height], unit),
+      sizes: { length, height, thickness: getWallThickness(wall) },
+      ...(room ? { zoneId: room.id } : {}),
+    }
+  }
+
+  if (node.type === 'window' || node.type === 'door') {
+    const opening = node as WindowNode & { wallId?: string }
+    const wallId = opening.wallId ?? opening.parentId ?? undefined
+    const room = wallId ? roomOfWall(nodes, levelId, wallId) : undefined
+    return {
+      ...base,
+      name: named(node.type === 'window' ? 'Window' : 'Door'),
+      size: dimensions([opening.width, opening.height], unit),
+      sizes: {
+        width: opening.width,
+        height: opening.height,
+        sill: Math.max(0, opening.position[1] - opening.height / 2),
+      },
+      ...(opening.parentId ? { parentId: opening.parentId } : {}),
+      ...(room ? { zoneId: room.id } : {}),
+    }
+  }
+
+  if (node.type === 'item') {
+    const item = node as ItemNode
+    const [width, height, depth] = getScaledDimensions(item)
+    const room = zonesOf(nodes, levelId).find((zone) =>
+      insidePolygon([item.position[0], item.position[2]], zone.polygon),
+    )
+    const onItem = item.parentId && nodes[item.parentId]?.type === 'item'
+    return {
+      ...base,
+      name: named(item.asset.name?.trim() || 'Item'),
+      size: wide(width, unit),
+      sizes: { width, depth, height },
+      ...(onItem ? { parentId: item.parentId as string } : {}),
+      ...(room ? { zoneId: room.id } : {}),
+    }
+  }
+
+  if (node.type === 'roof-segment') {
+    const { width, depth } = node as { width: number; depth: number }
+    return {
+      ...base,
+      name: named('Roof segment'),
+      size: dimensions([width, depth], unit),
+      sizes: { width, depth },
+    }
+  }
+
+  if (node.type === 'stair' || node.type === 'stair-segment') {
+    const stair = node as StairNode
+    const sizes: Record<string, number> = { width: stair.width ?? 1 }
+    if (stair.totalRise !== undefined) sizes.rise = stair.totalRise
+    return { ...base, name: named('Stair'), size: wide(sizes.width!, unit), sizes }
+  }
+
+  if (node.type === 'slab' || node.type === 'ceiling') {
+    const plate = node as SlabNode
+    const squareMetres = area([{ outer: plate.polygon, holes: [] }])
+    return {
+      ...base,
+      name: named(DEFAULT_NAMES[node.type] ?? sentence(node.type)),
+      size: areaLabel(squareMetres, unit),
+      sizes: { area: squareMetres },
+    }
+  }
+
+  return {
+    ...base,
+    name: named(DEFAULT_NAMES[node.type] ?? sentence(node.type)),
+    size: '',
+    sizes: {},
+  }
+}

package/src/lib/point-ask/dictation.ts

@@ -0,0 +1,79 @@
+// Dictate in the bubble (the owner said yes to voice, 8 October): the browser's own speech
+// recognition where it exists, hidden where it does not. The words fill the field and never send:
+// the person reads them and presses Enter.
+
+type RecognitionResult = { 0: { transcript: string }; isFinal: boolean; length: number }
+type RecognitionEvent = { resultIndex: number; results: ArrayLike<RecognitionResult> }
+type Recognition = {
+  lang: string
+  interimResults: boolean
+  continuous: boolean
+  onresult: ((event: RecognitionEvent) => void) | null
+  onend: (() => void) | null
+  onerror: ((event: { error: string }) => void) | null
+  start: () => void
+  stop: () => void
+  abort: () => void
+}
+type RecognitionConstructor = new () => Recognition
+
+function constructorOf(): RecognitionConstructor | null {
+  if (typeof window === 'undefined') return null
+  const w = window as unknown as {
+    SpeechRecognition?: RecognitionConstructor
+    webkitSpeechRecognition?: RecognitionConstructor
+  }
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null
+}
+
+export function isDictationSupported(): boolean {
+  return constructorOf() !== null
+}
+
+export type Dictation = { stop: () => void }
+
+/**
+ * Starts listening. `onText` gets the whole transcript so far (interim words included) each time
+ * it changes; `onEnd` fires once when listening stops, by `stop`, by silence or by an error.
+ */
+export function startDictation(options: {
+  lang?: string
+  onText: (text: string) => void
+  onEnd: (reason: 'stopped' | 'error', error?: string) => void
+}): Dictation | null {
+  const Ctor = constructorOf()
+  if (!Ctor) return null
+  const recognition = new Ctor()
+  recognition.lang =
+    options.lang ?? (typeof navigator === 'undefined' ? 'en-US' : navigator.language)
+  recognition.interimResults = true
+  recognition.continuous = true
+  let finished = false
+  const finish = (reason: 'stopped' | 'error', error?: string) => {
+    if (finished) return
+    finished = true
+    options.onEnd(reason, error)
+  }
+  recognition.onresult = (event) => {
+    let text = ''
+    for (let i = 0; i < event.results.length; i++) text += event.results[i]?.[0]?.transcript ?? ''
+    options.onText(text.trim())
+  }
+  recognition.onerror = (event) => finish('error', event.error)
+  recognition.onend = () => finish('stopped')
+  try {
+    recognition.start()
+  } catch (error) {
+    finish('error', error instanceof Error ? error.message : String(error))
+    return null
+  }
+  return {
+    stop: () => {
+      try {
+        recognition.stop()
+      } catch {
+        finish('stopped')
+      }
+    },
+  }
+}

package/src/lib/point-ask/edge-marker.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from 'bun:test'
+import { edgeMarker } from './edge-marker'
+
+// A pin whose element is out of view (spec 2.6, "work outside the view shows an edge marker"):
+// the marker sits on the viewport's edge, on the line from its centre towards the pin, and points
+// at it. Written first: a marker for a pin that is in view; one off the edge on the wrong side;
+// a pin behind the camera sending the marker nowhere.
+const VIEW = { x0: 0, y0: 0, x1: 1000, y1: 600 }
+
+describe('edgeMarker', () => {
+  test('a pin in view needs none', () => {
+    expect(edgeMarker({ x: 400, y: 300 }, VIEW)).toBeNull()
+  })
+
+  test('a pin to the right sits on the right edge, level with the line to it', () => {
+    const marker = edgeMarker({ x: 2000, y: 300 }, VIEW)!
+
+    expect(marker.x).toBe(1000 - 18)
+    expect(marker.y).toBeCloseTo(300, 5)
+    expect(marker.angle).toBeCloseTo(0, 5)
+  })
+
+  test('a pin above points up from the top edge', () => {
+    const marker = edgeMarker({ x: 500, y: -900 }, VIEW)!
+
+    expect(marker.y).toBe(18)
+    expect(marker.x).toBeCloseTo(500, 5)
+    expect(marker.angle).toBeCloseTo(-90, 5)
+  })
+
+  test('a pin beyond a corner sits in that corner region, on the line from the centre', () => {
+    const marker = edgeMarker({ x: 3000, y: 1800 }, VIEW)!
+
+    expect(marker.x).toBeLessThanOrEqual(1000 - 18)
+    expect(marker.y).toBeLessThanOrEqual(600 - 18)
+    // On the line through the centre (500, 300) and the pin: equal slope.
+    const slope = (marker.y - 300) / (marker.x - 500)
+    expect(slope).toBeCloseTo((1800 - 300) / (3000 - 500), 5)
+  })
+
+  test('is always inside the inset viewport', () => {
+    for (const p of [
+      { x: -500, y: 1200 },
+      { x: 1500, y: -300 },
+      { x: 2000, y: 640 },
+      { x: -50, y: 300 },
+    ]) {
+      const marker = edgeMarker(p, VIEW)!
+      expect(marker.x).toBeGreaterThanOrEqual(18)
+      expect(marker.x).toBeLessThanOrEqual(1000 - 18)
+      expect(marker.y).toBeGreaterThanOrEqual(18)
+      expect(marker.y).toBeLessThanOrEqual(600 - 18)
+    }
+  })
+
+  test('a pin behind the camera has no direction: the marker sits at the bottom, pointing down', () => {
+    const marker = edgeMarker(null, VIEW)!
+
+    expect(marker).toEqual({ x: 500, y: 600 - 18, angle: 90 })
+  })
+})

package/src/lib/point-ask/edge-marker.ts

@@ -0,0 +1,27 @@
+import type { Rect, ScreenPoint } from './types'
+
+/**
+ * Where the edge marker of an off-screen pin goes: on the viewport's inset edge, on the line from
+ * the viewport's centre towards the pin, turned to point at it. Null when the pin is in view; a
+ * pin behind the camera (`point` null) has no direction, so its marker sits at the bottom.
+ */
+export function edgeMarker(
+  point: ScreenPoint | null,
+  viewport: Rect,
+  inset = 18,
+): { x: number; y: number; angle: number } | null {
+  const cx = (viewport.x0 + viewport.x1) / 2
+  const cy = (viewport.y0 + viewport.y1) / 2
+  const hw = (viewport.x1 - viewport.x0) / 2 - inset
+  const hh = (viewport.y1 - viewport.y0) / 2 - inset
+  if (!point) return { x: cx, y: cy + hh, angle: 90 }
+  const dx = point.x - cx
+  const dy = point.y - cy
+  if (Math.abs(dx) <= hw + inset && Math.abs(dy) <= hh + inset) return null
+  // Scale the direction until it touches the inset rectangle.
+  const scale = Math.min(
+    dx === 0 ? Number.POSITIVE_INFINITY : hw / Math.abs(dx),
+    dy === 0 ? Number.POSITIVE_INFINITY : hh / Math.abs(dy),
+  )
+  return { x: cx + dx * scale, y: cy + dy * scale, angle: (Math.atan2(dy, dx) * 180) / Math.PI }
+}

package/src/lib/point-ask/frame-loop.ts

@@ -0,0 +1,25 @@
+// One requestAnimationFrame loop for everything that follows the camera (the outline corners, the
+// bubble, the pins): it runs only while something subscribes, and each subscriber gets the frame's
+// delta in seconds (capped, so a hidden tab does not fling springs on return).
+
+type FrameFn = (dt: number, now: number) => void
+
+const subscribers = new Set<FrameFn>()
+let frame = 0
+let last = 0
+
+function tick(now: number) {
+  const dt = Math.min(0.05, last ? (now - last) / 1000 : 0.016)
+  last = now
+  for (const fn of [...subscribers]) fn(dt, now)
+  frame = subscribers.size > 0 ? requestAnimationFrame(tick) : 0
+  if (!frame) last = 0
+}
+
+export function subscribeFrame(fn: FrameFn): () => void {
+  subscribers.add(fn)
+  if (!frame && typeof requestAnimationFrame === 'function') frame = requestAnimationFrame(tick)
+  return () => {
+    subscribers.delete(fn)
+  }
+}

package/src/lib/point-ask/history-marks.test.ts

@@ -0,0 +1,94 @@
+import { describe, expect, test } from 'bun:test'
+import { createdSince, markHistory, stateAfterMark, stepsSince } from './history-marks'
+
+// Undo from a pin steps back through what the ask's turn wrote. The scene history keeps only the
+// last 50 steps and a Cmd+Z shrinks it, so a length alone lies: the mark holds the last step that
+// stood when the turn began, and the steps since are counted from where that step is now.
+const steps = (n: number, from = 0) => Array.from({ length: n }, (_, i) => ({ id: from + i }))
+
+describe('stepsSince', () => {
+  test('counts the steps pushed after the mark', () => {
+    const past = steps(3)
+    const mark = markHistory(past)
+    const later = [...past, ...steps(2, 3)]
+
+    expect(stepsSince(later, mark)).toBe(2)
+    expect(stepsSince(past, mark)).toBe(0)
+  })
+
+  test('an empty history at the mark counts everything since', () => {
+    const mark = markHistory([])
+
+    expect(stepsSince(steps(4), mark)).toBe(4)
+  })
+
+  test('still counts once old steps fall off the front (the history limit)', () => {
+    const past = steps(50)
+    const mark = markHistory(past)
+    const later = [...past, ...steps(3, 50)].slice(3)
+
+    expect(stepsSince(later, mark)).toBe(3)
+  })
+
+  test('is null when the marked step itself fell off, so the whole turn cannot be undone', () => {
+    const past = steps(50)
+    const mark = markHistory(past)
+    const later = [...past, ...steps(60, 50)].slice(-50)
+
+    expect(stepsSince(later, mark)).toBeNull()
+  })
+
+  test('is null after the person undid back past the mark', () => {
+    const past = steps(5)
+    const mark = markHistory(past)
+
+    expect(stepsSince(past.slice(0, 2), mark)).toBeNull()
+  })
+
+  test('a Cmd+Z that only took part of the turn leaves the rest countable', () => {
+    const past = steps(3)
+    const mark = markHistory(past)
+    const written = [...past, ...steps(4, 3)]
+    const afterOneUndo = written.slice(0, -1)
+
+    expect(stepsSince(afterOneUndo, mark)).toBe(3)
+  })
+})
+
+describe('stateAfterMark', () => {
+  test('is the state the first step since the mark was taken from', () => {
+    const past = steps(3)
+    const mark = markHistory(past)
+    const later = [...past, ...steps(2, 3)]
+
+    expect(stateAfterMark(later, mark)).toBe(later[3] ?? null)
+  })
+
+  test('with an empty history at the mark it is the oldest state', () => {
+    const mark = markHistory([])
+    const later = steps(2)
+
+    expect(stateAfterMark(later, mark)).toBe(later[0] ?? null)
+  })
+
+  test('is null when nothing was pushed since the mark, or the marked step is gone', () => {
+    const past = steps(3)
+    const mark = markHistory(past)
+
+    expect(stateAfterMark(past, mark)).toBeNull()
+    expect(stateAfterMark(steps(2, 10), mark)).toBeNull()
+  })
+})
+
+describe('createdSince', () => {
+  test('is the nodes the scene has now that the earlier state did not', () => {
+    const before = { wall_a: {}, window_a: {} }
+    const now = { wall_a: {}, window_a: {}, window_b: {}, wall_b: {} }
+
+    expect(createdSince(before, now).sort()).toEqual(['wall_b', 'window_b'])
+  })
+
+  test('a node only changed is not created, and one deleted is not either', () => {
+    expect(createdSince({ a: {}, b: {} }, { a: { width: 2 } })).toEqual([])
+  })
+})