@pascal-app/editor 1.0.1 → 1.0.3

package/src/lib/material-catalog-model.ts

@@ -0,0 +1,72 @@
+'use client'
+
+import {
+  getCatalogMaterialById,
+  getDynamicLibraryMaterials,
+  getLibraryMaterialIdFromRef,
+  getLibraryMaterialsVersion,
+  getMaterialsForCategory,
+  MATERIAL_CATEGORIES,
+  type MaterialSource,
+  subscribeLibraryMaterials,
+  toLibraryMaterialRef,
+} from '@pascal-app/core'
+import { useEffect, useState, useSyncExternalStore } from 'react'
+
+export type MaterialSourceFilter = MaterialSource
+const SOURCE_FILTERS: { id: MaterialSourceFilter; label: string }[] = [
+  { id: 'pascal', label: 'Pascal' },
+  { id: 'mine', label: 'Mine' },
+  { id: 'workspace', label: 'Workspace' },
+  { id: 'community', label: 'Community' },
+]
+
+export function useMaterialCatalogModel(
+  selectedMaterialPreset?: string,
+  onSelectMaterialPreset?: (ref: string) => void,
+  disabled = false,
+) {
+  const [selectedCategory, setCategory] = useState<(typeof MATERIAL_CATEGORIES)[number]>(
+    MATERIAL_CATEGORIES[0],
+  )
+  const [sourceFilter, setSourceFilter] = useState<MaterialSourceFilter>('pascal')
+  useSyncExternalStore(
+    subscribeLibraryMaterials,
+    getLibraryMaterialsVersion,
+    getLibraryMaterialsVersion,
+  )
+  const availableCategories = MATERIAL_CATEGORIES.filter(
+    (category) => getMaterialsForCategory(category).length > 0,
+  )
+  const visibleSourceFilters = SOURCE_FILTERS.filter(
+    (filter) =>
+      filter.id !== 'workspace' ||
+      getDynamicLibraryMaterials().some((item) => item.source === 'workspace'),
+  )
+  const itemsFor = (category: typeof selectedCategory) =>
+    getMaterialsForCategory(category).filter((item) => (item.source ?? 'pascal') === sourceFilter)
+  useEffect(() => {
+    const entry = getCatalogMaterialById(
+      getLibraryMaterialIdFromRef(selectedMaterialPreset) ?? undefined,
+    )
+    if (entry?.category) setCategory(entry.category)
+  }, [selectedMaterialPreset])
+  const select = (id: string) => {
+    if (!disabled) onSelectMaterialPreset?.(toLibraryMaterialRef(id))
+  }
+  const setSelectedCategory = (category: typeof selectedCategory) => {
+    setCategory(category)
+    const first = itemsFor(category)[0]
+    if (first) select(first.id)
+  }
+  return {
+    selectedCategory,
+    setSelectedCategory,
+    sourceFilter,
+    setSourceFilter,
+    visibleSourceFilters,
+    availableCategories,
+    catalogItems: itemsFor(selectedCategory),
+    select,
+  }
+}

package/src/lib/material-paint-panel-model.ts

@@ -0,0 +1,76 @@
+'use client'
+
+import {
+  type AnyNodeId,
+  generateSceneMaterialId,
+  toSceneMaterialRef,
+  useScene,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect } from 'react'
+import useEditor from '../store/use-editor'
+import { buildResetSurfaceMaterialUpdates, resolvePaintTargetFromSelection } from './material-paint'
+
+export function useMaterialPaintPanelModel(enabled = true) {
+  const activePaintMaterial = useEditor((state) => state.activePaintMaterial)
+  const activePaintTarget = useEditor((state) => state.activePaintTarget)
+  const setActivePaintMaterial = useEditor((state) => state.armMaterialPaint)
+  const setActivePaintTarget = useEditor((state) => state.setActivePaintTarget)
+  const paintEraser = useEditor((state) => state.paintEraser)
+  const setPaintEraser = useEditor((state) => state.setPaintEraser)
+  const selectedId = useViewer((state) =>
+    state.selection.selectedIds.length === 1 ? (state.selection.selectedIds[0] ?? null) : null,
+  )
+  const paintTarget = useScene((state) =>
+    resolvePaintTargetFromSelection({ nodes: state.nodes, selectedId }),
+  )
+  const materials = useScene((state) => state.materials)
+  const canResetSelection = paintTarget !== null
+  useEffect(() => {
+    if (enabled && paintTarget) setActivePaintTarget(paintTarget)
+  }, [enabled, paintTarget, setActivePaintTarget])
+  const resetSelection = () => {
+    const scene = useScene.getState()
+    const node = selectedId ? scene.nodes[selectedId as AnyNodeId] : undefined
+    if (node) scene.updateNodes(buildResetSurfaceMaterialUpdates(scene.nodes, node))
+  }
+  const createCustomMaterial = () => {
+    const scene = useScene.getState()
+    const id = generateSceneMaterialId()
+    scene.addSceneMaterial({
+      id,
+      name: `Material ${Object.keys(scene.materials).length + 1}`,
+      material: {
+        preset: 'custom',
+        properties: {
+          color: '#ffffff',
+          roughness: 0.5,
+          metalness: 0,
+          opacity: 1,
+          transparent: false,
+          side: 'front',
+        },
+      },
+    })
+    setActivePaintMaterial({
+      materialPreset: toSceneMaterialRef(id),
+      sourceTarget: useEditor.getState().activePaintTarget,
+    })
+    return id
+  }
+  const selectMaterial = (materialPreset: string) =>
+    setActivePaintMaterial({ materialPreset, sourceTarget: useEditor.getState().activePaintTarget })
+  return {
+    activePaintMaterial,
+    activePaintTarget,
+    setActivePaintMaterial,
+    paintEraser,
+    setPaintEraser,
+    materials,
+    materialCount: Object.keys(materials).length,
+    canResetSelection,
+    resetSelection,
+    createCustomMaterial,
+    selectMaterial,
+  }
+}

package/src/lib/overlay-transform.test.ts

@@ -0,0 +1,28 @@
+import { test } from 'bun:test'
+import assert from 'node:assert/strict'
+import { Group } from 'three'
+import { copyOverlayWorldTransform } from './overlay-transform'
+
+test('opening overlays retain the source transform through God-mode zoom and rotation', () => {
+  const model = new Group()
+  const wall = new Group()
+  const opening = new Group()
+  model.add(wall)
+  wall.add(opening)
+  wall.rotation.y = 0.8
+  opening.position.set(2, 1.5, 0.1)
+  const portal = new Group()
+  portal.position.set(4, 1, -2)
+  portal.rotation.y = -0.4
+  const overlay = new Group()
+  portal.add(overlay)
+  for (const scale of [0.01, 0.2, 1, 4, 0.05]) {
+    model.scale.set(scale, scale * 2, scale)
+    model.rotation.y += 0.2
+    copyOverlayWorldTransform(opening, overlay)
+    overlay.updateWorldMatrix(true, false)
+    overlay.matrixWorld.elements.forEach((value, i) => {
+      assert.ok(Math.abs(value - opening.matrixWorld.elements[i]!) < 1e-8)
+    })
+  }
+})

package/src/lib/overlay-transform.ts

@@ -0,0 +1,12 @@
+import type { Object3D } from 'three'
+
+/** Preserve scale and shear when an overlay is portalled outside its source hierarchy. */
+export function copyOverlayWorldTransform(source: Object3D, overlay: Object3D) {
+  source.updateWorldMatrix(true, false)
+  overlay.parent?.updateWorldMatrix(true, false)
+  overlay.matrixAutoUpdate = false
+  if (overlay.parent)
+    overlay.matrix.copy(overlay.parent.matrixWorld).invert().multiply(source.matrixWorld)
+  else overlay.matrix.copy(source.matrixWorld)
+  overlay.matrixWorldNeedsUpdate = true
+}

package/src/lib/panel-rows.ts

@@ -0,0 +1,75 @@
+import type { AnyNode, AnyNodeDefinition, AnyNodeId } from '@pascal-app/core'
+
+export type PanelIcon = { color?: string; src?: string }
+
+export type PanelAction = {
+  icon?: PanelIcon
+  disabled?: boolean
+  id: string
+  label: string
+  onSelect?: () => void
+}
+
+export type PanelRow = { section?: string } & (
+  | {
+      id: string
+      kind: 'action'
+      icon?: PanelIcon
+      label: string
+      onSelect?: () => void
+      disabled?: boolean
+    }
+  | {
+      actions: PanelAction[]
+      id: string
+      kind: 'actions'
+    }
+  | {
+      id: string
+      kind: 'choice'
+      label: string
+      onSelect?: () => void
+      value: string
+    }
+  | {
+      getValue: () => string
+      id: string
+      kind: 'subscribed-choice'
+      label: string
+      onSelect?: () => void
+      subscribe: (listener: () => void) => () => void
+    }
+  | {
+      id: string
+      kind: 'cycle'
+      label: string
+      next: () => void
+      previous: () => void
+      value: string
+    }
+  | {
+      id: string
+      kind: 'stepper'
+      label: string
+      max: number
+      min: number
+      onChange: (value: number) => void
+      step: number
+      unit?: string
+      value: number
+    }
+)
+
+export const PANEL_MODEL_EXTENSION = 'pascal:editor/panel-model'
+
+export type NodePanelModel<N extends AnyNode = AnyNode> = {
+  rows: (context: {
+    node: N
+    nodes: Record<AnyNodeId, AnyNode>
+    update: (patch: Partial<N>) => void
+  }) => PanelRow[]
+}
+
+export function getNodePanelModel(definition: AnyNodeDefinition | undefined) {
+  return definition?.extensions?.[PANEL_MODEL_EXTENSION] as NodePanelModel | undefined
+}

package/src/lib/panel-tool-options.test.ts

@@ -0,0 +1,34 @@
+import { expect, test } from 'bun:test'
+import { createToolHintsStore } from './panel-tool-options'
+
+test('tool hints share subscriptions, react to visibility and chip state, and unsubscribe', () => {
+  let visible = false
+  let value = 'auto'
+  let subscriptions = 0
+  let cleanups = 0
+  const subscribe = (_listener: () => void) => {
+    subscriptions++
+    return () => {
+      cleanups++
+    }
+  }
+  const store = createToolHintsStore([
+    {
+      key: 'P',
+      label: 'Placement',
+      visible: { subscribe, value: () => visible },
+      chip: { subscribe, value: () => value, cycle: () => {}, labels: { auto: 'Auto' } },
+    },
+  ])
+  const cleanup = store.subscribe(() => {})
+  expect(subscriptions).toBe(1)
+  const hidden = store.getSnapshot()
+  visible = true
+  expect(store.getSnapshot()).not.toBe(hidden)
+  const shown = store.getSnapshot()
+  value = 'roof'
+  expect(store.getSnapshot()).not.toBe(shown)
+  expect(store.getSnapshot()).toBe(store.getSnapshot())
+  cleanup()
+  expect(cleanups).toBe(1)
+})

package/src/lib/panel-tool-options.ts

@@ -0,0 +1,46 @@
+'use client'
+
+import { nodeRegistry, type ToolHint, useRegistryVersion } from '@pascal-app/core'
+import { useMemo, useSyncExternalStore } from 'react'
+import useEditor from '../store/use-editor'
+
+export type PanelToolOption = {
+  id: string
+  label: string
+  value: string
+  choices: readonly { value: string; label: string; description?: string }[]
+  set: (value: string) => void
+}
+
+export function createToolHintsStore(hints: readonly ToolHint[]) {
+  return {
+    subscribe(listener: () => void) {
+      const subscriptions = hints.flatMap((hint) => [hint.chip?.subscribe, hint.visible?.subscribe])
+      const cleanups = [...new Set(subscriptions)].flatMap((subscribe) =>
+        subscribe ? [subscribe(listener)] : [],
+      )
+      return () => {
+        for (const cleanup of cleanups) cleanup()
+      }
+    },
+    getSnapshot: () =>
+      JSON.stringify(hints.map((hint) => [hint.visible?.value() ?? true, hint.chip?.value()])),
+  }
+}
+
+export function useVisibleToolHints(hints: readonly ToolHint[] = []) {
+  const draftVertexCount = useEditor((state) => state.draftVertexCount)
+  const store = useMemo(() => createToolHintsStore(hints), [hints])
+  useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot)
+  return hints.filter(
+    (hint) =>
+      !(hint.key === 'Shift' && hint.label === 'Cycle snapping mode') &&
+      (hint.visible?.value() ?? true) &&
+      (hint.minDraftVertices == null || draftVertexCount >= hint.minDraftVertices),
+  )
+}
+
+export function usePanelToolHints(kind: string | null | undefined) {
+  useRegistryVersion()
+  return useVisibleToolHints(kind ? nodeRegistry.get(kind)?.toolHints : undefined)
+}

package/src/lib/parametric-node-update.ts

@@ -0,0 +1,37 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  nodeRegistry,
+  type ParametricDescriptor,
+  useScene,
+} from '@pascal-app/core'
+
+export function commitParametricNodeFields(
+  nodeId: AnyNodeId,
+  requestedPatch: Partial<AnyNode>,
+): void {
+  const scene = useScene.getState()
+  const node = scene.nodes[nodeId]
+  if (!node) return
+
+  const parametrics = nodeRegistry.get(node.type)?.parametrics as
+    | ParametricDescriptor<AnyNode>
+    | undefined
+  let patch = requestedPatch as Record<string, unknown>
+  if (parametrics?.derive) {
+    const next = { ...node, ...patch } as AnyNode
+    patch = {
+      ...patch,
+      ...parametrics.derive(next, patch as Partial<AnyNode>, node),
+    }
+  }
+
+  const updates: { id: AnyNodeId; data: Partial<AnyNode> }[] = [
+    { id: nodeId, data: patch as Partial<AnyNode> },
+  ]
+  if (parametrics?.reconcile) {
+    const next = { ...node, ...patch } as AnyNode
+    updates.push(...parametrics.reconcile(node, next))
+  }
+  scene.updateNodes(updates)
+}

package/src/lib/scene.test.ts

@@ -0,0 +1,99 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import { nodeRegistry, registerNode, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { z } from 'zod'
+import useEditor from '../store/use-editor'
+import { normalizeSceneGraphNodes, syncEditorSelectionFromCurrentScene } from './scene'
+
+const building = {
+  children: ['level_scene-root'],
+  id: 'building_scene-root',
+  object: 'node',
+  parentId: null,
+  position: [0, 0, 0],
+  rotation: [0, 0, 0],
+  type: 'building',
+  visible: true,
+}
+
+const level = {
+  children: ['wall_scene-root'],
+  id: 'level_scene-root',
+  level: 0,
+  object: 'node',
+  parentId: building.id,
+  type: 'level',
+  visible: true,
+}
+
+const wall = {
+  children: [],
+  end: [4, 0],
+  id: 'wall_scene-root',
+  object: 'node',
+  parentId: level.id,
+  start: [0, 0],
+  type: 'wall',
+  visible: true,
+}
+
+describe('scene selection synchronization', () => {
+  beforeEach(() => {
+    useViewer.getState().resetSelection()
+    useEditor.setState({ mode: 'select', phase: 'site', tool: null })
+  })
+
+  test('enters the first level when a scene graph is rooted at a building', () => {
+    useScene.setState({
+      nodes: {
+        [building.id]: building,
+        [level.id]: level,
+        [wall.id]: wall,
+      },
+      rootNodeIds: [building.id],
+    } as never)
+
+    syncEditorSelectionFromCurrentScene()
+
+    expect(useViewer.getState().selection).toMatchObject({
+      buildingId: building.id,
+      levelId: level.id,
+    })
+    expect(useEditor.getState().phase).toBe('structure')
+  })
+})
+
+describe('scene graph normalization', () => {
+  test('materializes registered schema defaults before the graph reaches renderers', () => {
+    const restoreRegistry = nodeRegistry._snapshot()
+    try {
+      registerNode({
+        kind: 'test-scene-normalization',
+        schema: z.object({
+          id: z.string(),
+          position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+          rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+          type: z.literal('test-scene-normalization'),
+        }),
+        schemaVersion: 1,
+      } as never)
+
+      expect(
+        normalizeSceneGraphNodes({
+          test: { id: 'test', type: 'test-scene-normalization' },
+          unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
+        }),
+      ).toEqual({
+        test: {
+          id: 'test',
+          position: [0, 0, 0],
+          rotation: [0, 0, 0],
+          type: 'test-scene-normalization',
+        },
+        unknown: { id: 'unknown', type: 'unknown-kind', custom: true },
+      })
+    } finally {
+      restoreRegistry()
+    }
+  })
+})

package/src/lib/scene.ts

@@ -276,9 +276,13 @@ function getRestoredSelectionForScene(
 export function syncEditorSelectionFromCurrentScene() {
   const sceneNodes = useScene.getState().nodes as Record<string, any>
   const sceneRootIds = useScene.getState().rootNodeIds
-  const siteNode = sceneRootIds[0] ? sceneNodes[sceneRootIds[0]] : null
   const resolve = (child: any) => (typeof child === 'string' ? sceneNodes[child] : child)
-  const firstBuilding = siteNode?.children?.map(resolve).find((n: any) => n?.type === 'building')
+  const rootNodes = sceneRootIds.map((id) => sceneNodes[id]).filter(Boolean)
+  const firstBuilding =
+    rootNodes.find((node) => node.type === 'building') ??
+    rootNodes
+      .flatMap((node) => (Array.isArray(node.children) ? node.children.map(resolve) : []))
+      .find((node) => node?.type === 'building')
   const firstLevel = firstBuilding?.children?.map(resolve).find((n: any) => n?.type === 'level')
   const restoredEditorUiState = normalizePersistedEditorUiState(useEditor.getState())
   const shouldRestoreEditorUiState = hasCustomPersistedEditorUiState(restoredEditorUiState)
@@ -396,11 +400,25 @@ function hasUsableSceneGraph(sceneGraph?: SceneGraph | null): sceneGraph is Scen
   )
 }
 
+export function normalizeSceneGraphNodes(
+  nodes: Readonly<Record<string, unknown>>,
+): Record<string, unknown> {
+  return Object.fromEntries(
+    Object.entries(nodes).map(([id, value]) => {
+      if (!value || typeof value !== 'object' || Array.isArray(value)) return [id, value]
+      const type = (value as { type?: unknown }).type
+      if (typeof type !== 'string') return [id, value]
+      const parsed = nodeRegistry.get(type)?.schema.safeParse(value)
+      return [id, parsed?.success ? parsed.data : value]
+    }),
+  )
+}
+
 export function applySceneGraphToEditor(sceneGraph?: SceneGraph | null) {
   const defaultInstalledPlugins = editorHostPanelRegistry.getDefaultInstalledPluginIds()
   if (hasUsableSceneGraph(sceneGraph)) {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = sceneGraph
-    useScene.getState().setScene(nodes as any, rootNodeIds as any, {
+    useScene.getState().setScene(normalizeSceneGraphNodes(nodes) as any, rootNodeIds as any, {
       collections: collections as any,
       materials: materials as any,
       installedPlugins: installedPlugins ?? defaultInstalledPlugins,

package/src/lib/snapping-mode.test.ts

@@ -1,5 +1,9 @@
 import { describe, expect, it } from 'bun:test'
-import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
+import {
+  GROUP_MOVE_DRAG_LABEL,
+  GROUP_ROTATE_DRAG_LABEL,
+  ROTATE_HANDLE_DRAG_LABEL,
+} from './contextual-help'
 import {
   cycleSnappingModeIn,
   DEFAULT_SNAPPING_MODE,
@@ -49,6 +53,12 @@ describe('resolveSnapFlags', () => {
 })
 
 describe('per-context snapping', () => {
+  it('rotation defaults to angles and cycles independently to free rotation', () => {
+    expect(defaultSnappingModeFor('rotation')).toBe('angles')
+    expect(snappingModesFor('rotation')).toEqual(['angles', 'off'])
+    expect(cycleSnappingModeIn('rotation', 'angles')).toBe('off')
+    expect(cycleSnappingModeIn('rotation', 'off')).toBe('angles')
+  })
   it('items default to magnetic alignment with no angle lock', () => {
     expect(defaultSnappingModeFor('item')).toBe('lines')
     expect(snappingModesFor('item')).toEqual(['lines', 'grid', 'off'])
@@ -132,7 +142,8 @@ describe('snapContextOf (profile-driven, node-declared)', () => {
     expect(ctx({ kind: 'handle-drag', nodeId: 'unknown_1' })).toBeNull()
     expect(
       ctx({ kind: 'handle-drag', nodeId: 'cabinet-module_1', handle: ROTATE_HANDLE_DRAG_LABEL }),
-    ).toBeNull()
+    ).toBe('rotation')
+    expect(ctx({ kind: 'handle-drag', handle: GROUP_ROTATE_DRAG_LABEL })).toBe('rotation')
   })
 
   it('gives mesh rotation the angle context and other edit operations polygon snapping', () => {

package/src/lib/snapping-mode.ts

@@ -1,5 +1,9 @@
 import type { SnapProfile } from '@pascal-app/core'
-import { GROUP_MOVE_DRAG_LABEL, ROTATE_HANDLE_DRAG_LABEL } from './contextual-help'
+import {
+  GROUP_MOVE_DRAG_LABEL,
+  GROUP_ROTATE_DRAG_LABEL,
+  ROTATE_HANDLE_DRAG_LABEL,
+} from './contextual-help'
 
 /**
  * Snapping mode is a single global, user-cyclable control that maps onto the
@@ -68,14 +72,13 @@ export function nextSnappingMode(mode: SnappingMode): SnappingMode {
 // alignment lines). The mode is remembered per context and shown live, so it's
 // never a silent surprise — it just matches what you're doing.
 
-export type SnapContext = 'wall' | 'item' | 'polygon'
+export type SnapContext = 'wall' | 'item' | 'polygon' | 'rotation'
 
 // The cyclable mode-set for a context (distinct from the node's `SnapProfile`).
 type SnapModeSet = { modes: SnappingMode[]; default: SnappingMode }
 
 // `modes[0]` is the cycle's first entry; `default` is what a context starts at.
-// The 'wall' set is the ONLY one with an angle lock — it applies solely when
-// you're setting a segment's DIRECTION (wall/fence drafting + endpoint drag).
+// The 'wall' set includes angle lock when setting a segment's direction.
 // Translating a whole wall, curving it, or drawing/moving a slab can't change an
 // angle, so those use the no-angle 'polygon' set.
 const SNAP_PROFILES: Record<SnapContext, SnapModeSet> = {
@@ -88,9 +91,10 @@ const SNAP_PROFILES: Record<SnapContext, SnapModeSet> = {
   // whole wall/fence translate, curve reshape, polygon boundary edit. Grid by
   // default, NO angle lock.
   polygon: { modes: ['grid', 'lines', 'off'], default: 'grid' },
+  rotation: { modes: ['angles', 'off'], default: 'angles' },
 }
 
-export const SNAP_CONTEXTS: SnapContext[] = ['wall', 'item', 'polygon']
+export const SNAP_CONTEXTS: SnapContext[] = ['wall', 'item', 'polygon', 'rotation']
 
 export function snappingModesFor(context: SnapContext): SnappingMode[] {
   return SNAP_PROFILES[context].modes
@@ -171,7 +175,8 @@ export function snapContextOf(args: {
         ? contextForProfile(profileOfNode?.(scope.nodeId), scope.operator === 'rotate')
         : null
     case 'handle-drag':
-      if (scope.handle === ROTATE_HANDLE_DRAG_LABEL) return null
+      if (scope.handle === ROTATE_HANDLE_DRAG_LABEL || scope.handle === GROUP_ROTATE_DRAG_LABEL)
+        return 'rotation'
       return scope.nodeId ? contextForProfile(profileOfNode?.(scope.nodeId), false) : null
     case 'placing':
     case 'moving':

package/src/lib/spatial-drag-plane.test.ts

@@ -0,0 +1,53 @@
+import { expect, test } from 'bun:test'
+import { Matrix4, Ray, Vector3 } from 'three'
+import {
+  createSpatialDragPlane,
+  intersectSpatialDragPlane,
+  spatialDragLocalY,
+} from './spatial-drag-plane'
+
+test('controller translation gives continuous motion at the grabbed height', () => {
+  const start = new Vector3(2, 2.4, 1)
+  const ray = new Ray(new Vector3(2, 3.4, 2), new Vector3(0, -1, -1).normalize())
+  const plane = createSpatialDragPlane(start, ray)
+  for (let step = 0; step <= 10; step++) {
+    const moved = ray.clone()
+    moved.origin.z += step / 10
+    const hit = intersectSpatialDragPlane(moved, plane, new Vector3())!
+    expect(hit.x).toBeCloseTo(2)
+    expect(hit.y).toBeCloseTo(2.4)
+    expect(hit.z).toBeCloseTo(1 + step / 10)
+  }
+})
+
+test('horizontal rays use a stable facing plane and grazing rays are ignored', () => {
+  const ray = new Ray(new Vector3(0, 1, 2), new Vector3(0, 0, -1))
+  const plane = createSpatialDragPlane(new Vector3(0, 1, 0), ray)
+  ray.origin.x = 0.1
+  expect(intersectSpatialDragPlane(ray, plane, new Vector3())?.x).toBeCloseTo(0.1)
+  ray.direction.set(1, 0, -0.001).normalize()
+  expect(intersectSpatialDragPlane(ray, plane, new Vector3())).toBeNull()
+})
+
+test('drag plane follows a rotated, scaled building frame', () => {
+  const transform = new Matrix4().makeRotationZ(Math.PI / 4).scale(new Vector3(0.2, 0.2, 0.2))
+  const point = new Vector3(0, 2, 0).applyMatrix4(transform)
+  const up = new Vector3(0, 1, 0).transformDirection(transform)
+  const ray = new Ray(point.clone().add(up), up.clone().negate())
+  const plane = createSpatialDragPlane(point, ray, transform)
+  expect(intersectSpatialDragPlane(ray, plane, new Vector3())?.distanceTo(point)).toBeLessThan(1e-8)
+})
+
+test('height drag uses model metres at human and miniature scales without an initial jump', () => {
+  for (const scale of [1, 0.2, 2]) {
+    const frame = new Matrix4().makeRotationY(0.7).scale(new Vector3(scale, scale, scale))
+    frame.setPosition(2, 4, -3)
+    const inverse = frame.clone().invert()
+    const start = new Vector3(1, 2.5, 3).applyMatrix4(frame)
+    const initialY = spatialDragLocalY(start, inverse)
+    for (let step = 0; step <= 10; step++) {
+      const moved = start.clone().add(new Vector3(0, (scale * step) / 10, 0))
+      expect(2.5 + spatialDragLocalY(moved, inverse) - initialY).toBeCloseTo(2.5 + step / 10)
+    }
+  }
+})