@pascal-app/editor 1.0.7 → 1.1.1

package/src/lib/floorplan/floorplan-readonly.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { LevelNode, WallNode } from '@pascal-app/core/schema'
-import { buildFloorplanContext } from './floorplan-readonly'
-
-const viewState = {
-  selected: false,
-  unit: 'metric' as const,
-  highlighted: false,
-  hovered: false,
-  moving: false,
-  palette: undefined,
-}
-
-describe('read-only floorplan context', () => {
-  test('does not invent siblings for parentless nodes', () => {
-    const first = LevelNode.parse({ id: 'level_first', type: 'level' })
-    const second = LevelNode.parse({ id: 'level_second', type: 'level' })
-    const nodes = { [first.id]: first, [second.id]: second }
-
-    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([])
-  })
-
-  test('resolves same-kind siblings from the parent child order', () => {
-    const first = WallNode.parse({
-      id: 'wall_first',
-      type: 'wall',
-      parentId: 'level_ground',
-      start: [0, 0],
-      end: [1, 0],
-    })
-    const second = WallNode.parse({
-      id: 'wall_second',
-      type: 'wall',
-      parentId: 'level_ground',
-      start: [1, 0],
-      end: [2, 0],
-    })
-    const level = LevelNode.parse({
-      id: 'level_ground',
-      type: 'level',
-      children: [first.id, second.id],
-    })
-    const nodes = { [level.id]: level, [first.id]: first, [second.id]: second }
-
-    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([second])
-  })
-})

package/src/lib/floorplan/floorplan-readonly.ts

@@ -1,95 +0,0 @@
-import type { AnyNode, AnyNodeId, FloorplanPalette, GeometryContext } from '@pascal-app/core'
-import {
-  createFloorplanContextExtensions,
-  type FloorplanWallDimensionFaces,
-} from './floorplan-extension'
-
-export type FloorplanViewState = {
-  automaticDimensions?: boolean
-  selected: boolean
-  unit: 'metric' | 'imperial'
-  metricNotation?: 'meters' | 'millimeters'
-  purpose?: 'edit' | 'document'
-  /** Sheet drafting conventions (see `FloorplanContextExtension.drafting`). */
-  drafting?: boolean
-  /** Room labels drawn as screen pills (see `FloorplanContextExtension.roomLabelOverlay`). */
-  roomLabelOverlay?: boolean
-  wallDimensionFaces?: FloorplanWallDimensionFaces
-  highlighted: boolean
-  hovered: boolean
-  moving: boolean
-  focusedUnitId?: string
-  focusedUnitMemberIds?: readonly string[]
-  palette: FloorplanPalette | undefined
-}
-
-export function buildFloorplanContext(
-  node: AnyNode,
-  nodes: Record<string, AnyNode>,
-  viewState: FloorplanViewState,
-  levelData?: unknown,
-): GeometryContext {
-  const resolve = <N = AnyNode>(id: AnyNodeId): N | undefined => nodes[id] as N | undefined
-  const childIds = (node as { children?: AnyNodeId[] }).children
-  const children = Array.isArray(childIds)
-    ? childIds.map((id) => nodes[id]).filter((child): child is AnyNode => child !== undefined)
-    : []
-  const parentId = node.parentId as AnyNodeId | null
-  const parent = parentId ? (nodes[parentId] ?? null) : null
-  let siblings: AnyNode[] = []
-  if (parent) {
-    const parentChildIds = (parent as { children?: AnyNodeId[] }).children
-    siblings = Array.isArray(parentChildIds)
-      ? parentChildIds
-          .filter((id) => id !== node.id)
-          .map((id) => nodes[id])
-          .filter((sibling): sibling is AnyNode => sibling?.type === node.type)
-      : Object.values(nodes).filter(
-          (candidate) =>
-            candidate.id !== node.id &&
-            candidate.type === node.type &&
-            candidate.parentId === node.parentId,
-        )
-  }
-
-  return {
-    resolve,
-    children,
-    siblings,
-    parent,
-    levelData,
-    sceneNodes: nodes,
-    extensions: createFloorplanContextExtensions({
-      automaticDimensions: viewState.automaticDimensions,
-      metricNotation: viewState.metricNotation ?? 'meters',
-      purpose: viewState.purpose ?? 'edit',
-      drafting: viewState.drafting === true,
-      roomLabelOverlay: viewState.roomLabelOverlay === true,
-      wallDimensionFaces: viewState.wallDimensionFaces,
-    }),
-    viewState: viewState.palette
-      ? {
-          selected: viewState.selected,
-          unit: viewState.unit,
-          highlighted: viewState.highlighted,
-          hovered: viewState.hovered,
-          moving: viewState.moving,
-          focusedUnitId: viewState.focusedUnitId,
-          focusedUnitMemberIds: viewState.focusedUnitMemberIds,
-          palette: viewState.palette,
-        }
-      : undefined,
-  }
-}
-
-export function floorplanLayerRank(type: string): number {
-  switch (type) {
-    case 'zone':
-      return 0
-    case 'slab':
-    case 'ceiling':
-      return 1
-    default:
-      return 2
-  }
-}

package/src/lib/floorplan/marks.test.ts

@@ -1,213 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { AnyNode, AnyNodeId } from '@pascal-app/core'
-import { persistResolvedMarks, resolveMarkDetail, resolveMarks } from './marks'
-
-/**
- * Fixture: a rectangular level, walls running clockwise on screen from the
- * north-west corner.
- *
- *   north  [0,0] → [6,0]      doors d_n1 @1, d_n2 @4
- *   east   [6,0] → [6,4]      window w_e1 @2
- *   south  [6,4] → [0,4]      door d_s1 @2
- *   west   [0,4] → [0,0]      (interior partition, no openings)
- */
-function fixture(levelOrdinal = 0): Record<string, AnyNode> {
-  const nodes: Record<string, AnyNode> = {}
-  const node = (value: Record<string, unknown>) => {
-    nodes[value.id as string] = {
-      object: 'node',
-      parentId: null,
-      visible: true,
-      metadata: {},
-      children: [],
-      ...value,
-    } as unknown as AnyNode
-  }
-
-  node({
-    id: 'level_1',
-    type: 'level',
-    level: levelOrdinal,
-    children: ['w_n', 'w_e', 'w_s', 'w_w'],
-  })
-  node({
-    id: 'w_n',
-    type: 'wall',
-    parentId: 'level_1',
-    start: [0, 0],
-    end: [6, 0],
-    thickness: 0.15,
-    frontSide: 'exterior',
-    backSide: 'interior',
-    children: ['d_n1', 'd_n2'],
-  })
-  node({
-    id: 'w_e',
-    type: 'wall',
-    parentId: 'level_1',
-    start: [6, 0],
-    end: [6, 4],
-    thickness: 0.15,
-    frontSide: 'exterior',
-    backSide: 'interior',
-    children: ['win_e1'],
-  })
-  node({
-    id: 'w_s',
-    type: 'wall',
-    parentId: 'level_1',
-    start: [6, 4],
-    end: [0, 4],
-    thickness: 0.15,
-    frontSide: 'exterior',
-    backSide: 'interior',
-    children: ['d_s1'],
-  })
-  node({
-    id: 'w_w',
-    type: 'wall',
-    parentId: 'level_1',
-    start: [0, 4],
-    end: [0, 0],
-    thickness: 0.1,
-    frontSide: 'interior',
-    backSide: 'interior',
-    children: [],
-  })
-
-  const door = (id: string, wallId: string, along: number) =>
-    node({
-      id,
-      type: 'door',
-      parentId: wallId,
-      wallId,
-      width: 0.9,
-      height: 2.1,
-      position: [along, 1.05, 0],
-    })
-  door('d_n1', 'w_n', 1)
-  door('d_n2', 'w_n', 4)
-  door('d_s1', 'w_s', 2)
-  node({
-    id: 'win_e1',
-    type: 'window',
-    parentId: 'w_e',
-    wallId: 'w_e',
-    width: 1.2,
-    height: 1.2,
-    position: [2, 1.1, 0],
-  })
-  return nodes
-}
-
-describe('resolveMarks', () => {
-  test('doors are D101…, windows W101… on level 0', () => {
-    const marks = resolveMarks(fixture(), 'level_1' as AnyNodeId)
-    expect(marks.get('d_n1')).toBe('D101')
-    expect(marks.get('d_n2')).toBe('D102')
-    expect(marks.get('d_s1')).toBe('D103')
-    expect(marks.get('win_e1')).toBe('W101')
-  })
-
-  test('level ordinal shifts the base by 100', () => {
-    const marks = resolveMarks(fixture(1), 'level_1' as AnyNodeId)
-    expect(marks.get('d_n1')).toBe('D201')
-    expect(marks.get('win_e1')).toBe('W201')
-  })
-
-  test('openings are ordered clockwise from the north-west, exterior walls first', () => {
-    const nodes = fixture()
-    // Move the west partition's opening onto it to prove interior comes last.
-    ;(nodes.w_w as unknown as { children: string[] }).children = ['d_w1']
-    nodes.d_w1 = {
-      object: 'node',
-      id: 'd_w1',
-      type: 'door',
-      parentId: 'w_w',
-      wallId: 'w_w',
-      visible: true,
-      metadata: {},
-      width: 0.8,
-      height: 2.1,
-      position: [2, 1.05, 0],
-      children: [],
-    } as unknown as AnyNode
-    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
-    // North (exterior) first, then the other exterior walls, interior last.
-    expect(marks.get('d_w1')).toBe('D104')
-  })
-
-  test('an explicit mark wins and is never reassigned', () => {
-    const nodes = fixture()
-    ;(nodes.d_n2 as unknown as { mark: string }).mark = 'D-GARAGE'
-    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
-    expect(marks.get('d_n2')).toBe('D-GARAGE')
-    expect(marks.get('d_n1')).toBe('D101')
-    expect(marks.get('d_s1')).toBe('D102')
-  })
-
-  test('duplicate explicit marks are reported, not silently renumbered', () => {
-    const nodes = fixture()
-    ;(nodes.d_n1 as unknown as { mark: string }).mark = 'D101'
-    ;(nodes.d_n2 as unknown as { mark: string }).mark = 'D101'
-    const resolution = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
-    expect(resolution.issues).toEqual(['Duplicate door mark D101 (2 instances)'])
-  })
-
-  test('numbering is stable under insertion once persisted', () => {
-    const nodes = fixture()
-    const first = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
-    expect([...first.assignments.values()]).toEqual(['D101', 'D102', 'D103', 'W101'])
-
-    // Persist, the way an edit session does the first time it resolves.
-    const written = persistResolvedMarks(first, (id, data) => {
-      ;(nodes[id] as unknown as Record<string, unknown>).mark = data.mark
-    })
-    expect(written).toBe(4)
-
-    // Insert a door BETWEEN d_n1 and d_n2 on the same wall.
-    ;(nodes.w_n as unknown as { children: string[] }).children = ['d_n1', 'd_new', 'd_n2']
-    nodes.d_new = {
-      object: 'node',
-      id: 'd_new',
-      type: 'door',
-      parentId: 'w_n',
-      wallId: 'w_n',
-      visible: true,
-      metadata: {},
-      width: 0.8,
-      height: 2.1,
-      position: [2.5, 1.05, 0],
-      children: [],
-    } as unknown as AnyNode
-
-    const second = resolveMarkDetail(nodes, 'level_1' as AnyNodeId)
-    // Existing doors keep their marks; the new one takes the next free number.
-    expect(second.marks.get('d_n1')).toBe('D101')
-    expect(second.marks.get('d_n2')).toBe('D102')
-    expect(second.marks.get('d_s1')).toBe('D103')
-    expect(second.marks.get('d_new')).toBe('D104')
-    expect([...second.assignments.keys()]).toEqual(['d_new'])
-  })
-
-  test('WITHOUT persisting, inserting mid-wall renumbers — which is why we persist', () => {
-    const nodes = fixture()
-    ;(nodes.w_n as unknown as { children: string[] }).children = ['d_n1', 'd_new', 'd_n2']
-    nodes.d_new = {
-      object: 'node',
-      id: 'd_new',
-      type: 'door',
-      parentId: 'w_n',
-      wallId: 'w_n',
-      visible: true,
-      metadata: {},
-      width: 0.8,
-      height: 2.1,
-      position: [2.5, 1.05, 0],
-      children: [],
-    } as unknown as AnyNode
-    const marks = resolveMarks(nodes, 'level_1' as AnyNodeId)
-    expect(marks.get('d_new')).toBe('D102')
-    expect(marks.get('d_n2')).toBe('D103')
-  })
-})

package/src/lib/floorplan/marks.ts

@@ -1,238 +0,0 @@
-import type {
-  AnyNode,
-  AnyNodeId,
-  DoorNode,
-  LevelNode,
-  WallNode,
-  WindowNode,
-} from '@pascal-app/core'
-
-/**
- * Deterministic door / window marks per level — WS3.
- *
- * `packages/core/src/schema/nodes/door.ts:75-79` promises "the deterministic
- * level fallback (101, 102, ...)"; this is the implementation.
- *
- * Numbering
- * ---------
- *   base   = (level.level + 1) * 100          — level 0 → 100, level 1 → 200
- *   doors  = `D${base + n}`   → D101, D102 …
- *   windows= `W${base + n}`   → W101, W102 …
- *
- * Order
- * -----
- * Openings are visited **clockwise** around the level, starting from the
- * north-west-most exterior wall, exterior walls first and interior walls
- * after. Clockwise is the ascending-angle sweep of the wall midpoint about
- * the level centroid, anchored on the north-west diagonal (plan axes are
- * x east, z south — z grows down the screen — so a screen-clockwise sweep
- * is increasing atan2(z, x)). Openings on the same wall are ordered along
- * the wall direction.
- *
- * Stability
- * ---------
- * An explicit `mark` on the node always wins and is never reassigned.
- * `resolveMarks` also reports, in `assignments`, the marks it invented for
- * nodes that had none — the caller is expected to PERSIST those back onto
- * `node.mark` the first time they are resolved in an edit session
- * (`persistResolvedMarks`). That is what makes numbering stable under
- * insertion: once written, an existing opening keeps its number forever and
- * a newly inserted opening only ever takes the next free number. Without
- * the write-back, inserting a door in the middle of a wall would silently
- * renumber every door after it.
- */
-
-export type OpeningMarkKind = 'door' | 'window'
-
-export type MarkResolution = {
-  /** Every door and window on the level → its mark. */
-  marks: ReadonlyMap<string, string>
-  /** Only the marks that were invented (node.mark was empty). */
-  assignments: ReadonlyMap<string, string>
-  /** Duplicate explicit marks and other reportable defects. */
-  issues: readonly string[]
-}
-
-export type MarkSceneInput = {
-  nodes: Readonly<Record<string, AnyNode>>
-}
-
-/**
- * Resolve marks for every door and window under `levelId`.
- *
- * `scene` may be a `{ nodes }` snapshot or the raw node map.
- */
-export function resolveMarks(
-  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
-  levelId: AnyNodeId,
-): Map<string, string> {
-  return new Map(resolveMarkDetail(scene, levelId).marks)
-}
-
-export function resolveMarkDetail(
-  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
-  levelId: AnyNodeId,
-): MarkResolution {
-  const nodes = normalizeNodes(scene)
-  const level = nodes[levelId]
-  const ordinal = level && level.type === 'level' ? ((level as LevelNode).level ?? 0) : 0
-  const base = (Math.max(0, ordinal) + 1) * 100
-
-  const openings = orderedOpenings(nodes, levelId)
-  const marks = new Map<string, string>()
-  const assignments = new Map<string, string>()
-  const issues: string[] = []
-
-  for (const kind of ['door', 'window'] as const) {
-    const prefix = kind === 'door' ? 'D' : 'W'
-    const list = openings.filter((opening) => opening.type === kind)
-    const used = new Set<string>()
-    const explicitOwners = new Map<string, string[]>()
-
-    for (const opening of list) {
-      const explicit = opening.mark?.trim()
-      if (!explicit) continue
-      marks.set(opening.id, explicit)
-      const normalized = explicit.toLocaleUpperCase()
-      used.add(normalized)
-      const owners = explicitOwners.get(normalized)
-      if (owners) owners.push(opening.id)
-      else explicitOwners.set(normalized, [opening.id])
-    }
-
-    let sequence = 1
-    for (const opening of list) {
-      if (marks.has(opening.id)) continue
-      let candidate = `${prefix}${base + sequence}`
-      while (used.has(candidate.toLocaleUpperCase())) {
-        sequence++
-        candidate = `${prefix}${base + sequence}`
-      }
-      marks.set(opening.id, candidate)
-      assignments.set(opening.id, candidate)
-      used.add(candidate.toLocaleUpperCase())
-      sequence++
-    }
-
-    for (const [mark, owners] of explicitOwners) {
-      if (owners.length > 1) {
-        issues.push(`Duplicate ${kind} mark ${mark} (${owners.length} instances)`)
-      }
-    }
-  }
-
-  return { marks, assignments, issues }
-}
-
-/**
- * Write invented marks back onto the nodes so numbering never drifts.
- *
- * Call once per level per edit session (the caller decides when — this
- * module stays pure). `update` is typically `sceneApi.update`.
- */
-export function persistResolvedMarks(
-  resolution: MarkResolution,
-  update: (id: AnyNodeId, data: Record<string, unknown>) => void,
-): number {
-  let written = 0
-  for (const [id, mark] of resolution.assignments) {
-    update(id as AnyNodeId, { mark })
-    written++
-  }
-  return written
-}
-
-// ── Ordering ─────────────────────────────────────────────────────────
-
-type Opening = (DoorNode | WindowNode) & { type: 'door' | 'window' }
-
-/**
- * Every door and window under the level, clockwise from the NW-most
- * exterior wall, exterior walls first.
- */
-export function orderedOpenings(
-  nodes: Readonly<Record<string, AnyNode>>,
-  levelId: AnyNodeId,
-): Opening[] {
-  const walls: WallNode[] = []
-  const orphanOpenings: Opening[] = []
-
-  const visit = (id: string) => {
-    const node = nodes[id]
-    if (!node) return
-    if (node.visible === false) return
-    if (node.type === 'wall') walls.push(node as WallNode)
-    else if (node.type === 'door' || node.type === 'window') {
-      const opening = node as Opening
-      if (!opening.wallId || !nodes[opening.wallId]) orphanOpenings.push(opening)
-    }
-    for (const childId of (node as { children?: string[] }).children ?? []) visit(childId)
-  }
-  visit(levelId)
-
-  const centroid = wallCentroid(walls)
-  const ordered = [...walls].sort((left, right) => {
-    const leftExterior = isExteriorWall(left) ? 0 : 1
-    const rightExterior = isExteriorWall(right) ? 0 : 1
-    if (leftExterior !== rightExterior) return leftExterior - rightExterior
-    return clockwiseKey(left, centroid) - clockwiseKey(right, centroid)
-  })
-
-  const result: Opening[] = []
-  for (const wall of ordered) {
-    const wallOpenings: Opening[] = []
-    for (const childId of wall.children ?? []) {
-      const child = nodes[childId]
-      if (child && child.visible !== false && (child.type === 'door' || child.type === 'window')) {
-        wallOpenings.push(child as Opening)
-      }
-    }
-    wallOpenings.sort((left, right) => left.position[0] - right.position[0])
-    result.push(...wallOpenings)
-  }
-  result.push(...orphanOpenings)
-  return result
-}
-
-function wallCentroid(walls: readonly WallNode[]): [number, number] {
-  if (walls.length === 0) return [0, 0]
-  let x = 0
-  let z = 0
-  for (const wall of walls) {
-    x += (wall.start[0] + wall.end[0]) / 2
-    z += (wall.start[1] + wall.end[1]) / 2
-  }
-  return [x / walls.length, z / walls.length]
-}
-
-/**
- * Sweep key: 0 at the north-west direction, increasing clockwise on screen.
- *
- * Plan axes are x east, z south — z grows DOWN the screen — so a clockwise
- * screen sweep (up → right → down → left) is the INCREASING atan2(z, x)
- * direction. The north-west diagonal sits at atan2(-1, -1) = -3π/4, so
- * anchoring there and wrapping into [0, 2π) yields north, east, south, west.
- */
-const NORTH_WEST_ANGLE = (-3 * Math.PI) / 4
-
-function clockwiseKey(wall: WallNode, centroid: readonly [number, number]): number {
-  const midX = (wall.start[0] + wall.end[0]) / 2 - centroid[0]
-  const midZ = (wall.start[1] + wall.end[1]) / 2 - centroid[1]
-  let sweep = Math.atan2(midZ, midX) - NORTH_WEST_ANGLE
-  while (sweep < 0) sweep += Math.PI * 2
-  while (sweep >= Math.PI * 2) sweep -= Math.PI * 2
-  return sweep
-}
-
-function isExteriorWall(wall: WallNode): boolean {
-  return wall.frontSide === 'exterior' || wall.backSide === 'exterior'
-}
-
-function normalizeNodes(
-  scene: MarkSceneInput | Readonly<Record<string, AnyNode>>,
-): Readonly<Record<string, AnyNode>> {
-  const candidate = scene as MarkSceneInput
-  return candidate && typeof candidate === 'object' && 'nodes' in candidate
-    ? candidate.nodes
-    : (scene as Readonly<Record<string, AnyNode>>)
-}

package/src/lib/measurement-label.ts

@@ -1,68 +0,0 @@
-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,
-  ]
-}