@pascal-app/editor 1.0.7 → 1.1.1

package/src/store/use-editor.tsx

@@ -10,6 +10,7 @@ import {
   type ChimneyMaterialRole,
   DEFAULT_BRUSH_SETTINGS,
   type DormerSurfaceMaterialRole,
+  isMoveLocked,
   type LevelNode,
   nodeRegistry,
   type RoofSurfaceMaterialRole,
@@ -20,6 +21,15 @@ import {
   type WallSurfaceSide,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
+import {
+  cameraPoseStore,
+  type NavigationSyncPose,
+  type NavigationSyncPoseInput,
+  publishNavigationSyncPose,
+  type RoomKey,
+  sameRoom,
+  subscribeNavigationSyncPose,
+} from '@pascal-app/viewer/ui'
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 import {
@@ -55,7 +65,6 @@ import {
   type PaintHoverInfo,
   type PaintScope,
 } from '../lib/paint-scope'
-import { type RoomKey, sameRoom } from '../lib/room-selection'
 import {
   cycleSnappingModeIn,
   defaultSnappingModeFor,
@@ -65,8 +74,6 @@ import {
   snapContextOf,
   snappingModesFor,
 } from '../lib/snapping-mode'
-import { cameraPoseStore } from './camera-pose-store'
-import { publishNavigationSyncPoseToStore } from './navigation-sync-pose-store'
 import useInteractionScope from './use-interaction-scope'
 import {
   clampViewPaneRatio,
@@ -232,18 +239,6 @@ export type CatalogCategory =
 export type FloorplanSelectionTool = 'click' | 'marquee'
 export type GridSnapStep = 0.5 | 0.25 | 0.1 | 0.05
 
-export type NavigationSyncSource = '2d' | '3d'
-
-export type NavigationSyncPose = {
-  source: NavigationSyncSource
-  revision: number
-  target: [number, number, number]
-  azimuth: number
-  viewWidth: number
-}
-
-export type NavigationSyncPoseInput = Omit<NavigationSyncPose, 'revision'>
-
 // Combined tool type. Known literals keep autocomplete; the `(string & {})`
 // arm lets plugin-contributed tool ids (e.g. `'trees:tree'`) typecheck without
 // the host enumerating every plugin kind. The runtime dispatch is already
@@ -489,12 +484,13 @@ type EditorState = {
   setViewPinned: (viewId: string, pinned: boolean) => void
   isFloorplanHovered: boolean
   setFloorplanHovered: (hovered: boolean) => void
+  /** Mirror of viewer/ui's navigation sync store, kept for plugins that read it here. */
+  navigationSyncPose: NavigationSyncPose | null
+  publishNavigationSyncPose: (pose: NavigationSyncPoseInput) => void
   // Toggleable DWV riser-diagram (plumbing isometric) overlay.
   isRiserOpen: boolean
   setRiserOpen: (open: boolean) => void
   toggleRiserOpen: () => void
-  navigationSyncPose: NavigationSyncPose | null
-  publishNavigationSyncPose: (pose: NavigationSyncPoseInput) => void
   floorplanSelectionTool: FloorplanSelectionTool
   setFloorplanSelectionTool: (tool: FloorplanSelectionTool) => void
   gridSnapStep: GridSnapStep
@@ -1256,6 +1252,10 @@ const useEditor = create<EditorState>()(
           set({ placementDragMode: false })
           return
         }
+        if (isMoveLocked(node)) {
+          set({ placementDragMode: false })
+          return
+        }
         const targetNode = node
         const isNew = Boolean((targetNode as { metadata?: { isNew?: boolean } }).metadata?.isNew)
         if (isNew) {
@@ -1533,18 +1533,11 @@ const useEditor = create<EditorState>()(
         set((state) => ({ pinnedViews: { ...state.pinnedViews, [viewId]: pinned } })),
       isFloorplanHovered: false,
       setFloorplanHovered: (hovered) => set({ isFloorplanHovered: hovered }),
+      navigationSyncPose: null,
+      publishNavigationSyncPose,
       isRiserOpen: false,
       setRiserOpen: (open) => set({ isRiserOpen: open }),
       toggleRiserOpen: () => set((state) => ({ isRiserOpen: !state.isRiserOpen })),
-      navigationSyncPose: null,
-      publishNavigationSyncPose: (pose) => {
-        const navigationSyncPose = {
-          ...pose,
-          revision: (get().navigationSyncPose?.revision ?? 0) + 1,
-        }
-        publishNavigationSyncPoseToStore(navigationSyncPose)
-        set({ navigationSyncPose })
-      },
       floorplanSelectionTool: 'click' as FloorplanSelectionTool,
       setFloorplanSelectionTool: (tool) => set({ floorplanSelectionTool: tool }),
       gridSnapStep: DEFAULT_PERSISTED_EDITOR_LAYOUT_STATE.gridSnapStep,
@@ -1858,4 +1851,7 @@ usePaintRegionMode.subscribe((state) => {
   if (useEditor.getState().paintEraser !== paintEraser) useEditor.setState({ paintEraser })
 })
 
+// Published plugins read the 2D/3D navigation pose from the editor store; the shared store owns it.
+subscribeNavigationSyncPose((navigationSyncPose) => useEditor.setState({ navigationSyncPose }))
+
 export default useEditor

package/src/store/use-floorplan-annotation-visibility.ts

@@ -1,5 +1,10 @@
 'use client'
 
+import {
+  DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
+  type FloorplanWallDimensionFaces,
+  normalizeFloorplanWallDimensionFaces,
+} from '@pascal-app/core'
 import { create } from 'zustand'
 import { persist } from 'zustand/middleware'
 import {
@@ -8,11 +13,6 @@ import {
   type FloorplanAnnotationVisibility,
   normalizeFloorplanAnnotationVisibility,
 } from '../lib/floorplan/annotation-visibility'
-import {
-  DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
-  type FloorplanWallDimensionFaces,
-  normalizeFloorplanWallDimensionFaces,
-} from '../lib/floorplan/floorplan-extension'
 
 type PersistedFloorplanAnnotationState = {
   visibility: FloorplanAnnotationVisibility

package/src/store/use-placement-typing.test.ts

@@ -0,0 +1,165 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  isPlacementTypingKey,
+  PLACEMENT_TYPING_DISTANCE_OFFSET,
+  PLACEMENT_TYPING_LENGTH_ANGLE,
+  routePlacementTypingKey,
+  usePlacementTyping,
+} from './use-placement-typing'
+
+const key = (
+  k: string,
+  mods: Partial<Pick<KeyboardEvent, 'metaKey' | 'ctrlKey' | 'altKey'>> = {},
+) => ({
+  key: k,
+  metaKey: false,
+  ctrlKey: false,
+  altKey: false,
+  ...mods,
+})
+
+const beginTwoFields = (activeField: 0 | 1) => {
+  usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET, activeField })
+  return true
+}
+
+describe('usePlacementTyping', () => {
+  beforeEach(() => {
+    usePlacementTyping.getState().clear()
+  })
+
+  test('keeps two independent field buffers and toggles the active field', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET, fieldDefaults: ['1.2', '0'] })
+    typing.append('2')
+    typing.toggleField()
+    typing.append('-')
+    typing.append('4')
+
+    expect(usePlacementTyping.getState().fields).toEqual(['2', '-4'])
+    expect(usePlacementTyping.getState().fieldDefaults).toEqual(['1.2', '0'])
+    expect(usePlacementTyping.getState().activeField).toBe(1)
+  })
+
+  test('backspace only changes the active field', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET })
+    typing.append('25')
+    typing.toggleField()
+    typing.append('3')
+    typing.backspace()
+
+    expect(usePlacementTyping.getState().fields).toEqual(['25', ''])
+  })
+
+  test('publishes projection and an enter request without clearing input', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET })
+    typing.append('2')
+    typing.setProjectedPosition([2, 0, 1])
+    typing.requestCommit()
+
+    expect(usePlacementTyping.getState().projectedPosition).toEqual([2, 0, 1])
+    expect(usePlacementTyping.getState().submitRevision).toBe(1)
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('clear ends the session and forgets its labels', () => {
+    usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE })
+    usePlacementTyping.getState().append('3')
+    usePlacementTyping.getState().clear()
+    const state = usePlacementTyping.getState()
+    expect(state.isActive).toBe(false)
+    expect(state.fields).toEqual(['', ''])
+    expect(state.labels).toEqual([])
+  })
+})
+
+describe('routePlacementTypingKey', () => {
+  beforeEach(() => {
+    usePlacementTyping.getState().clear()
+  })
+
+  test('a digit or a leading dot opens a session on the first field', () => {
+    expect(routePlacementTypingKey(key('5'), { begin: beginTwoFields })).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['5', ''])
+    usePlacementTyping.getState().clear()
+    expect(routePlacementTypingKey(key('.'), { begin: beginTwoFields })).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['.', ''])
+  })
+
+  test('letters, signs and separators leave tool shortcuts alone until a session opens', () => {
+    for (const k of ['c', 'm', 't', 'f', '-', ' ', ',']) {
+      expect(routePlacementTypingKey(key(k), { begin: beginTwoFields })).toBeNull()
+    }
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+  })
+
+  test('no session opens when the tool refuses or offers no begin', () => {
+    expect(routePlacementTypingKey(key('5'), { begin: () => false })).toBeNull()
+    expect(routePlacementTypingKey(key('5'))).toBeNull()
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+  })
+
+  test('Tab opens a session on the second field only when the tool asks for it', () => {
+    expect(routePlacementTypingKey(key('Tab'), { begin: beginTwoFields })).toBeNull()
+    expect(routePlacementTypingKey(key('Tab'), { begin: beginTwoFields, tabBegins: true })).toBe(
+      'edit',
+    )
+    expect(usePlacementTyping.getState().activeField).toBe(1)
+  })
+
+  test('inside a session: unit letters extend, Tab and comma switch, Enter commits', () => {
+    routePlacementTypingKey(key('1'), { begin: beginTwoFields })
+    for (const k of ['8', '0', 'c', 'm']) routePlacementTypingKey(key(k))
+    expect(routePlacementTypingKey(key('Tab'))).toBe('edit')
+    routePlacementTypingKey(key('-'))
+    routePlacementTypingKey(key('2'))
+    expect(routePlacementTypingKey(key(','))).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['180cm', '-2'])
+    expect(usePlacementTyping.getState().activeField).toBe(0)
+    expect(routePlacementTypingKey(key('Enter'))).toBe('commit')
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('Backspace edits, Delete empties the active field', () => {
+    routePlacementTypingKey(key('4'), { begin: beginTwoFields })
+    routePlacementTypingKey(key('2'))
+    routePlacementTypingKey(key('Backspace'))
+    expect(usePlacementTyping.getState().fields[0]).toBe('4')
+    routePlacementTypingKey(key('Delete'))
+    expect(usePlacementTyping.getState().fields[0]).toBe('')
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('the first Escape only ends the session', () => {
+    routePlacementTypingKey(key('3'), { begin: beginTwoFields })
+    expect(routePlacementTypingKey(key('Escape'))).toBe('clear')
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+    expect(routePlacementTypingKey(key('Escape'))).toBeNull()
+  })
+
+  test('chords are never consumed', () => {
+    expect(
+      routePlacementTypingKey(key('5', { metaKey: true }), { begin: beginTwoFields }),
+    ).toBeNull()
+    routePlacementTypingKey(key('5'), { begin: beginTwoFields })
+    expect(routePlacementTypingKey(key('z', { ctrlKey: true }))).toBeNull()
+    expect(routePlacementTypingKey(key('Enter', { altKey: true }))).toBeNull()
+    expect(usePlacementTyping.getState().fields[0]).toBe('5')
+  })
+})
+
+describe('isPlacementTypingKey', () => {
+  test('accepts the measurement grammar', () => {
+    for (const k of ['0', '9', 'm', 'c', '.', "'", '"', '-', '+', ' ', '/']) {
+      expect(isPlacementTypingKey(k)).toBe(true)
+    }
+  })
+
+  test('rejects control keys and the field separator', () => {
+    for (const k of ['Enter', 'Escape', 'Tab', 'Shift', '', 'F1', ',']) {
+      expect(isPlacementTypingKey(k)).toBe(false)
+    }
+  })
+})

package/src/store/use-placement-typing.ts

@@ -0,0 +1,186 @@
+import type { MessageDescriptor } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/**
+ * Typed coordinate entry shared by the placement tools: a drafted wall's
+ * length/angle and a cabinet's distance/offset along its wall. One session at
+ * a time; the active tool owns what the two fields mean and reads them on
+ * every change, the HUD (`PlacementCoordinateInput`) only displays them.
+ */
+export type PlacementTypingField = 0 | 1
+export type PlacementTypingValues = [string, string]
+export type PlacementTypingProjection = [number, number, number]
+
+export const PLACEMENT_TYPING_DISTANCE_OFFSET: readonly MessageDescriptor[] = [
+  /* i18n */ { id: 'editor.placementTyping.distance', message: 'Distance' },
+  /* i18n */ { id: 'editor.placementTyping.offset', message: 'Offset' },
+]
+
+export const PLACEMENT_TYPING_LENGTH_ANGLE: readonly MessageDescriptor[] = [
+  /* i18n */ { id: 'editor.placementTyping.length', message: 'Length' },
+  /* i18n */ { id: 'editor.placementTyping.angle', message: 'Angle' },
+]
+
+export type PlacementTypingSession = {
+  /** What each field means, in field order; the HUD shows one box per label. */
+  labels: readonly MessageDescriptor[]
+  fieldDefaults?: PlacementTypingValues
+  activeField?: PlacementTypingField
+}
+
+export type PlacementTypingState = {
+  isActive: boolean
+  labels: readonly MessageDescriptor[]
+  fields: PlacementTypingValues
+  /** What an empty field stands for, shown as its placeholder. */
+  fieldDefaults: PlacementTypingValues
+  activeField: PlacementTypingField
+  projectedPosition: PlacementTypingProjection | null
+  submitRevision: number
+  begin: (session: PlacementTypingSession) => void
+  append: (value: string) => void
+  backspace: () => void
+  setField: (field: PlacementTypingField, value: string) => void
+  setActiveField: (field: PlacementTypingField) => void
+  toggleField: () => void
+  setProjectedPosition: (position: PlacementTypingProjection | null) => void
+  requestCommit: () => void
+  clear: () => void
+}
+
+const EMPTY_VALUES: PlacementTypingValues = ['', '']
+
+export const usePlacementTyping = create<PlacementTypingState>((set) => ({
+  isActive: false,
+  labels: [],
+  fields: [...EMPTY_VALUES],
+  fieldDefaults: [...EMPTY_VALUES],
+  activeField: 0,
+  projectedPosition: null,
+  submitRevision: 0,
+  begin: ({ labels, fieldDefaults = EMPTY_VALUES, activeField = 0 }) =>
+    set({
+      isActive: true,
+      labels,
+      fields: [...EMPTY_VALUES],
+      fieldDefaults: [...fieldDefaults],
+      activeField,
+      projectedPosition: null,
+    }),
+  append: (value) =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[state.activeField] += value
+      return { isActive: true, fields }
+    }),
+  backspace: () =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[state.activeField] = fields[state.activeField].slice(0, -1)
+      return { fields }
+    }),
+  setField: (field, value) =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[field] = value
+      return { isActive: true, fields }
+    }),
+  setActiveField: (activeField) => set({ activeField }),
+  toggleField: () => set((state) => ({ activeField: state.activeField === 0 ? 1 : 0 })),
+  setProjectedPosition: (projectedPosition) => set({ projectedPosition }),
+  requestCommit: () =>
+    set((state: PlacementTypingState) => ({ submitRevision: state.submitRevision + 1 })),
+  clear: () =>
+    set({
+      isActive: false,
+      labels: [],
+      fields: [...EMPTY_VALUES],
+      fieldDefaults: [...EMPTY_VALUES],
+      activeField: 0,
+      projectedPosition: null,
+    }),
+}))
+
+/** Keys that extend a field: digits, unit letters, separators, signs, fractions. */
+export function isPlacementTypingKey(key: string): boolean {
+  return key.length === 1 && /^[0-9a-zA-Z.'"+\-/ ]$/.test(key)
+}
+
+/**
+ * Keys that may open a session. Letters only ever continue a field, so a
+ * tool's single-letter shortcuts keep working until a number is typed.
+ */
+export function isPlacementTypingStartKey(key: string): boolean {
+  return key.length === 1 && /^[0-9.]$/.test(key)
+}
+
+export type PlacementTypingKeyOutcome = 'edit' | 'commit' | 'clear'
+
+export type PlacementTypingKeyOptions = {
+  /**
+   * Opens a session for a start key (or Tab, with `tabBegins`) when none is
+   * active. Returns false when the tool cannot take typed entry right now.
+   */
+  begin?: (activeField: PlacementTypingField) => boolean
+  /** Tab with no session opens one on the second field. */
+  tabBegins?: boolean
+}
+
+/**
+ * The one keyboard convention for typed entry. Tab or comma switches field,
+ * Enter asks the tool to commit, Escape clears the session (the tool's next
+ * Escape cancels its draft), Backspace edits and Delete empties the active
+ * field. Chords with Cmd/Ctrl/Alt are never consumed. Returns null when the
+ * key is not part of typed entry; the caller prevents default and stops
+ * propagation for every other outcome.
+ */
+export function routePlacementTypingKey(
+  event: Pick<KeyboardEvent, 'key' | 'metaKey' | 'ctrlKey' | 'altKey'>,
+  options: PlacementTypingKeyOptions = {},
+): PlacementTypingKeyOutcome | null {
+  if (event.metaKey || event.ctrlKey || event.altKey) return null
+  const typing = usePlacementTyping.getState()
+  const { key } = event
+  if (!typing.isActive) {
+    if (isPlacementTypingStartKey(key)) {
+      if (!options.begin?.(0)) return null
+      usePlacementTyping.getState().append(key)
+      return 'edit'
+    }
+    if (key === 'Tab' && options.tabBegins && options.begin?.(1)) return 'edit'
+    return null
+  }
+  if (key === 'Tab' || key === ',') {
+    typing.toggleField()
+    return 'edit'
+  }
+  if (key === 'Enter') return 'commit'
+  if (key === 'Escape') {
+    typing.clear()
+    return 'clear'
+  }
+  if (key === 'Backspace') {
+    typing.backspace()
+    return 'edit'
+  }
+  if (key === 'Delete') {
+    typing.setField(typing.activeField, '')
+    return 'edit'
+  }
+  if (isPlacementTypingKey(key)) {
+    typing.append(key)
+    return 'edit'
+  }
+  return null
+}
+
+/** Parse options for a typed length: a bare number is read in the display unit. */
+export function placementTypingLengthOptions(
+  unit: 'metric' | 'imperial',
+  metricNotation: 'meters' | 'millimeters',
+) {
+  return {
+    bareUnit: unit === 'imperial' ? 'in' : metricNotation === 'millimeters' ? 'mm' : 'm',
+    system: unit === 'imperial' ? ('imperial' as const) : ('metric' as const),
+  }
+}

package/src/store/use-wall-region-handles-selection.ts

@@ -1,10 +1,9 @@
 import { type AnyNodeId, useScene } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
+import { isTypingTarget, useViewer } from '@pascal-app/viewer'
 import { create } from 'zustand'
 import { hasLiveGestures } from '../lib/gesture-lifecycle'
 import { removeWallRegion } from '../lib/paint-regions'
 import { sfxEmitter } from '../lib/sfx-bus'
-import { isTypingTarget } from '../lib/typing-target'
 import useDeleteConfirmation from './use-delete-confirmation'
 import useInteractionScope from './use-interaction-scope'
 

package/src/components/editor/__bench__/room-label-placement.bench.ts

@@ -1,108 +0,0 @@
-import type { Polygon } from '@pascal-app/core'
-import {
-  type PillCandidate,
-  placePills,
-  type RoomHit,
-  type RoomLabelEntry,
-  roomAt,
-} from '../room-labels'
-
-// One room-label placement pass and one pointer pick, for a 900 × 600 px house of 31, 60 and 120
-// rooms (every third an L), printed as JSON medians in ms. Run with `bun run <this file>`.
-let seed = 11
-const random = () => {
-  seed = (seed * 1_103_515_245 + 12_345) % 2 ** 31
-  return seed / 2 ** 31
-}
-
-function house(count: number) {
-  const columns = Math.ceil(Math.sqrt(count * 1.5))
-  const rows = Math.ceil(count / columns)
-  const width = 900 / columns
-  const depth = 600 / rows
-  return Array.from({ length: count }, (_, i) => {
-    const left = 270 + (i % columns) * width
-    const top = 150 + Math.floor(i / columns) * depth
-    const right = left + width
-    const bottom = top + depth
-    const outer: [number, number][] =
-      i % 3 === 0
-        ? [
-            [left, top],
-            [right, top],
-            [right, top + depth / 2],
-            [left + width / 2, top + depth / 2],
-            [left + width / 2, bottom],
-            [left, bottom],
-          ]
-        : [
-            [left, top],
-            [right, top],
-            [right, bottom],
-            [left, bottom],
-          ]
-    const outline: Polygon = { outer, holes: [] }
-    const pill = 60 + random() * 110
-    const candidate: PillCandidate = {
-      id: `room_${i}`,
-      x: left + width / 4,
-      y: top + depth / 4,
-      size: [pill, 24, pill * 0.6],
-      area: width * depth * (i % 3 === 0 ? 0.75 : 1),
-      outline,
-    }
-    const entry: RoomLabelEntry = {
-      zoneId: candidate.id,
-      polygon: outer,
-      holes: [],
-      area: candidate.area,
-    }
-    return { candidate, entry }
-  })
-}
-
-const median = (samples: number[]) => samples.sort((a, b) => a - b)[samples.length >> 1]!
-
-const pane = { width: 1440, height: 900 }
-const results: Record<string, unknown> = {}
-for (const count of [31, 60, 120]) {
-  const rooms = house(count)
-  const candidates = rooms.map((room) => room.candidate)
-  const entries = rooms.map((room) => room.entry)
-  for (let i = 0; i < 20; i++) placePills(candidates, pane)
-  const cold: number[] = []
-  const warm: number[] = []
-  let previous = placePills(candidates, pane)
-  for (let i = 0; i < 100; i++) {
-    let started = performance.now()
-    placePills(candidates, pane)
-    cold.push(performance.now() - started)
-    started = performance.now()
-    previous = placePills(candidates, pane, previous)
-    warm.push(performance.now() - started)
-  }
-  const points = Array.from(
-    { length: 1000 },
-    (): RoomHit => [270 + random() * 900, 150 + random() * 600, 0],
-  )
-  for (const point of points) roomAt(entries, () => point)
-  const picks: number[] = []
-  for (let i = 0; i < 20; i++) {
-    const started = performance.now()
-    for (const point of points) roomAt(entries, () => point)
-    picks.push((performance.now() - started) / points.length)
-  }
-  const tiers = Object.fromEntries(
-    ['full', 'name', 'dot', 'hidden'].map((tier) => [
-      tier,
-      [...previous.values()].filter((placement) => placement.tier === tier).length,
-    ]),
-  )
-  results[count] = {
-    placeMs: median(cold),
-    placeWithPreviousMs: median(warm),
-    pickMs: median(picks),
-    tiers,
-  }
-}
-console.log(JSON.stringify(results, null, 2))