@pascal-app/editor 1.0.3 → 1.0.5

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([])
+  })
+})

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

@@ -0,0 +1,39 @@
+// Counting what an ask's turn wrote in the scene's undo history. The history is bounded (the last
+// 50 steps) and the person can Cmd+Z into it, so a length cannot say how many steps are the turn's:
+// a mark holds the last step standing when the turn began, and the steps since are counted from
+// where that step is now.
+
+export type HistoryMark = { ref: unknown | null; length: number }
+
+export function markHistory(past: readonly unknown[]): HistoryMark {
+  return { ref: past.at(-1) ?? null, length: past.length }
+}
+
+/**
+ * How many steps were pushed since `mark`, or null when the marked step is gone from the history
+ * (it fell off the front, or the person undid back past it): the turn can no longer be undone as a
+ * whole.
+ */
+export function stepsSince(past: readonly unknown[], mark: HistoryMark): number | null {
+  if (mark.ref === null) return past.length
+  const at = past.lastIndexOf(mark.ref)
+  return at < 0 ? null : past.length - 1 - at
+}
+
+/**
+ * The history state the turn's first step was taken from: the scene as it stood when the turn began.
+ * Null when nothing was pushed since the mark, or the marked step has gone from the history.
+ */
+export function stateAfterMark<T>(past: readonly T[], mark: HistoryMark): T | null {
+  if (mark.ref === null) return past[0] ?? null
+  const at = past.lastIndexOf(mark.ref as T)
+  return at < 0 ? null : (past[at + 1] ?? null)
+}
+
+/** The nodes in `now` that `before` had no entry for: what an undo of the steps in between will remove. */
+export function createdSince(
+  before: Record<string, unknown>,
+  now: Record<string, unknown>,
+): string[] {
+  return Object.keys(now).filter((id) => !(id in before))
+}

package/src/lib/point-ask/host-api.ts

@@ -0,0 +1,32 @@
+import { usePointAsk } from '../../store/use-point-ask'
+import { chatWentIdle, retryAsk } from './session'
+
+// What a host app (the hosted chat) tells Point and ask about itself, without importing the store.
+
+/** The host's "Playful touches" setting: false turns the region flash, the ripples and the sounds off. */
+export function setPointAskPlayful(playful: boolean) {
+  usePointAsk.getState().setPlayful(playful)
+}
+
+/** Pascal is on a turn: the bubble's Send says Queue, and a new ask waits its turn. */
+export function setPointAskBusy(busy: boolean) {
+  usePointAsk.getState().setBusy(busy)
+  if (!busy) chatWentIdle()
+}
+
+/**
+ * Messages already wait in the chat's queue (or are held there after an error): a new ask goes
+ * behind them, and the bubble says Queue, though Pascal is on no turn.
+ */
+export function setPointAskBehindQueue(behindQueue: boolean) {
+  usePointAsk.getState().setBehindQueue(behindQueue)
+}
+
+/**
+ * The chat's Retry on a message that was a Point and ask: the same ask again, with its own pin. False
+ * when the editor no longer has the pin (a reload, a collaborator's ask): the chat sends the words
+ * again as a plain message.
+ */
+export function retryPointAsk(askId: string): Promise<boolean> {
+  return retryAsk(askId)
+}

package/src/lib/point-ask/outline-box.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test } from 'bun:test'
+import { outlineBox } from './outline-box'
+
+// A room is a floor to the person pointing: its corner brackets frame the footprint, not the
+// storey-high box that would leave two of them floating in the sky (seen on a two-storey house).
+describe('outlineBox', () => {
+  const tall = {
+    min: [0, 0, 0] as [number, number, number],
+    max: [6, 4.5, 6] as [number, number, number],
+  }
+
+  test('a room is its footprint at the floor', () => {
+    expect(outlineBox('zone', tall)).toEqual({ min: [0, 0, 0], max: [6, 0.02, 6] })
+  })
+
+  test('everything else keeps its own box', () => {
+    for (const type of ['wall', 'window', 'door', 'item', 'stair', 'roof']) {
+      expect(outlineBox(type, tall)).toEqual(tall)
+    }
+  })
+
+  test('a room that already is flat is left as it is', () => {
+    const flat = {
+      min: [0, 2.55, 0] as [number, number, number],
+      max: [4, 2.55, 4] as [number, number, number],
+    }
+
+    expect(outlineBox('zone', flat)).toEqual({ min: [0, 2.55, 0], max: [4, 2.57, 4] })
+  })
+})

package/src/lib/point-ask/outline-box.ts

@@ -0,0 +1,11 @@
+import type { WorldBox } from '../../store/use-point-ask'
+
+/**
+ * The box the overlay frames for a pointed element: its own world box, except a room, whose box
+ * spans the storey but which the person means as a floor. A flat footprint keeps the corner
+ * brackets on the ground and the bubble beside the room, not up in the air.
+ */
+export function outlineBox(type: string, box: WorldBox): WorldBox {
+  if (type !== 'zone') return box
+  return { min: [...box.min], max: [box.max[0], box.min[1] + 0.02, box.max[2]] }
+}

package/src/lib/point-ask/overlay-metrics.ts

@@ -0,0 +1,6 @@
+// Where the editor floats its own chrome over the canvas, so a bubble keeps clear of it.
+export const VIEWPORT_INSET = 12
+/** The top bar and the camera controls strip. */
+export const BUBBLE_TOP_INSET = 56
+/** The action bar at the bottom centre. */
+export const BUBBLE_BOTTOM_INSET = 84